@heretek-ai/epistemic-swarm 0.7.11 → 0.7.13

package/runner/darkharvest_claims.py

@@ -0,0 +1,326 @@
+#!/usr/bin/env python3
+"""Darkharvest claim normalization, license cross-check, and repo validation.
+
+Heretek-AI/IUMBTEMS#5: darkharvest dossiers emit `candidate_repositories[]` with
+their own `source_hash` witnesses, but the auditor only reads
+`affirmative_claims` / `falsification_claims` — so `total_claims_audited` was
+always 0 and the dialectic was structurally inert. Separately, alpha and beta
+can disagree about a repo's license (observed: `MIT` vs `NOASSERTION` for the
+same repo, with alpha recommending `depend-or-vendor`) and nothing cross-checked
+them, because the audit produced no claims to compare.
+
+This module supplies the three missing pieces:
+- `normalize_dossier_claims` — fold darkharvest's shape into the standard claim
+  schema so one contract flows to the auditor, PCRB, and ledger.
+- `cross_check_repos` — alpha/beta license disagreement is a blocking finding,
+  resolved conservatively.
+- `RepoValidator` — ground-truth (existence / license / archived) with fail-open
+  offline behavior.
+"""
+
+import json
+import os
+import re
+import urllib.error
+import urllib.request
+from typing import Any, Dict, List, Optional, Tuple
+
+# Top-level dossier keys that *look* like audit output but are agent-authored.
+# Renamed to `self_reported_*` on load so no consumer mistakes them for verified
+# counts (see #5 layer 3).
+AUDIT_SHAPED_KEYS = frozenset(
+    {
+        "epistemic_audit",
+        "confidence",
+        "gaps",
+        "verified_claims",
+        "unverified_claims",
+        "verified_sources",
+        "total_sources",
+        "total_claims",
+        "total_candidates",
+        "claims_total",
+        "claims_verified",
+        "claims_unverified",
+        "claims_falsified",
+        "claims_unverifiable",
+        "rejected_claims",
+        "mean_epistemic_score",
+        "primary_sources",
+        "primary_benchmarks",
+        "technical_specs",
+        "peer_reviewed",
+    }
+)
+
+# Licenses that may be `depend`ed on or `vendor`ed. Everything else (incl.
+# unknown / NOASSERTION) resolves to clean-room-rebuild-only.
+PERMISSIVE_LICENSES = frozenset({"MIT", "APACHE-2.0", "BSD-3-CLAUSE", "ISC"})
+
+UNKNOWN_LICENSES = frozenset({"", "UNKNOWN", "NOASSERTION", "NONE", "OTHER"})
+
+
+def _norm_license(value: Any) -> str:
+    return str(value or "").strip().upper()
+
+
+def _is_permissive(value: Any) -> bool:
+    return _norm_license(value) in PERMISSIVE_LICENSES
+
+
+def sanitize_self_reported(dossier: Dict[str, Any]) -> Tuple[Dict[str, Any], List[str]]:
+    """Rename agent-authored audit-shaped keys; return (dossier, renamed_keys).
+
+    Never deletes — the values are preserved under `self_reported_*` so a human
+    can still see what the agent claimed, but nothing counts them.
+    """
+    renamed: List[str] = []
+    if not isinstance(dossier, dict):
+        return dossier, renamed
+    for key in list(dossier.keys()):
+        if key in AUDIT_SHAPED_KEYS:
+            dossier[f"self_reported_{key}"] = dossier.pop(key)
+            renamed.append(key)
+    return dossier, renamed
+
+
+def _repo_key(candidate: Dict[str, Any]) -> Optional[str]:
+    """Stable key for a candidate repo: `owner/repo`, lowercased."""
+    raw = str(candidate.get("name") or candidate.get("repo") or "").strip()
+    if not raw:
+        url = str(candidate.get("url") or "").strip()
+        match = re.search(r"github\.com/([^/]+/[^/#?]+)", url)
+        if match:
+            raw = match.group(1)
+    raw = raw.removesuffix(".git").strip("/")
+    return raw.lower() if raw else None
+
+
+def _verdict_claims(role: str, candidate: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """One standard claim per candidate verdict (verifiable when a quote exists)."""
+    name = candidate.get("name") or candidate.get("url") or "unknown-repo"
+    source_hash = candidate.get("source_hash")
+    source_url = candidate.get("url")
+    quote = candidate.get("verbatim_quote")
+    out: List[Dict[str, Any]] = []
+    for i, verdict in enumerate(candidate.get("verdicts") or [], start=1):
+        if not isinstance(verdict, dict):
+            continue
+        rid = candidate.get("repo_id") or name
+        out.append(
+            {
+                "claim_id": f"{rid}-{role}-V{i}",
+                "tag": "VERIFIED",
+                "statement": (
+                    f"{name}: {verdict.get('feature', '?')} → "
+                    f"{verdict.get('verdict', '?')} ({verdict.get('reason', '')})"
+                ),
+                "source_hash": source_hash,
+                "source_url": source_url,
+                # Prefer a verdict-specific quote; fall back to the candidate's.
+                "verbatim_quote": verdict.get("verbatim_quote") or quote,
+            }
+        )
+    return out
+
+
+def normalize_dossier_claims(
+    dossier: Dict[str, Any], role: str
+) -> List[Dict[str, Any]]:
+    """Standard-schema claims for a dossier.
+
+    Uses the canonical keys when present; otherwise (darkharvest) derives them
+    from `candidate_repositories[]` so the auditor has something to verify.
+    """
+    if not isinstance(dossier, dict):
+        return []
+    standard = dossier.get("affirmative_claims") or dossier.get("falsification_claims")
+    if isinstance(standard, list) and standard:
+        return [c for c in standard if isinstance(c, dict)]
+
+    out: List[Dict[str, Any]] = []
+    for candidate in dossier.get("candidate_repositories") or []:
+        if isinstance(candidate, dict):
+            out.extend(_verdict_claims(role, candidate))
+    return out
+
+
+def _resolved_policy(alpha: Dict[str, Any], beta: Dict[str, Any]) -> str:
+    """Conservative harvest policy when the two dossiers disagree."""
+    for side in (alpha, beta):
+        policy = str(side.get("harvest_policy") or "").lower()
+        risk = str(side.get("license_risk") or "").upper()
+        if policy == "clean-room-rebuild-only" or risk in (
+            "COPYLEFT_WARNING",
+            "PROHIBITIVE",
+        ):
+            return "clean-room-rebuild-only"
+    for side in (alpha, beta):
+        if not _is_permissive(side.get("license")):
+            return "clean-room-rebuild-only"
+    return "depend-or-vendor"
+
+
+class RepoValidator:
+    """Ground-truth repo checks via the GitHub API.
+
+    Fail-open: any network/timeout error yields `exists=None` and blocks nothing,
+    so an offline or rate-limited run degrades rather than aborting.
+    """
+
+    def __init__(
+        self,
+        token: Optional[str] = None,
+        timeout: float = 5.0,
+        enabled: bool = True,
+    ):
+        self.token = token if token is not None else os.environ.get("GITHUB_TOKEN")
+        self.timeout = timeout
+        self.enabled = enabled
+        self._cache: Dict[str, Dict[str, Any]] = {}
+
+    def validate(self, owner_repo: str) -> Dict[str, Any]:
+        key = owner_repo.strip().lower()
+        if key in self._cache:
+            return self._cache[key]
+        result = {"exists": None, "license": None, "archived": None}
+        if self.enabled and key:
+            result = self._fetch(owner_repo)
+        self._cache[key] = result
+        return result
+
+    def _fetch(self, owner_repo: str) -> Dict[str, Any]:
+        request = urllib.request.Request(
+            f"https://api.github.com/repos/{owner_repo}",
+            headers={
+                "Accept": "application/vnd.github+json",
+                "User-Agent": "iumbtems-darkharvest-audit",
+                **({"Authorization": f"Bearer {self.token}"} if self.token else {}),
+            },
+        )
+        try:
+            with urllib.request.urlopen(request, timeout=self.timeout) as resp:
+                data = json.loads(resp.read().decode("utf-8", errors="replace"))
+            license_field = data.get("license") or {}
+            return {
+                "exists": True,
+                "license": license_field.get("spdx_id"),
+                "archived": bool(data.get("archived")),
+            }
+        except urllib.error.HTTPError as e:
+            if e.code == 404:
+                return {"exists": False, "license": None, "archived": None}
+            return {"exists": None, "license": None, "archived": None}
+        except Exception:
+            return {"exists": None, "license": None, "archived": None}
+
+
+def cross_check_repos(
+    alpha_dossier: Dict[str, Any],
+    beta_dossier: Dict[str, Any],
+    validator: Optional[RepoValidator] = None,
+) -> List[Dict[str, Any]]:
+    """Blocking findings for license disagreement and ground-truth failures.
+
+    A dialectic that produces a `depend-or-vendor` verdict on an unstated license
+    must not reach a human as `divergence: 0`. Each finding carries the
+    conservative resolution.
+    """
+    alpha = {
+        key: c
+        for c in (alpha_dossier.get("candidate_repositories") or [])
+        if isinstance(c, dict) and (key := _repo_key(c))
+    }
+    beta = {
+        key: c
+        for c in (beta_dossier.get("candidate_repositories") or [])
+        if isinstance(c, dict) and (key := _repo_key(c))
+    }
+
+    findings: List[Dict[str, Any]] = []
+    for key in sorted(set(alpha) | set(beta)):
+        a = alpha.get(key)
+        b = beta.get(key)
+        if a and b:
+            alic, blic = (
+                _norm_license(a.get("license")),
+                _norm_license(b.get("license")),
+            )
+            if alic != blic:
+                findings.append(
+                    {
+                        "repo": key,
+                        "kind": "LICENSE_DISAGREEMENT",
+                        "severity": "BLOCKING",
+                        "alpha": {
+                            "license": a.get("license"),
+                            "risk": a.get("license_risk"),
+                        },
+                        "beta": {
+                            "license": b.get("license"),
+                            "risk": b.get("license_risk"),
+                        },
+                        "resolution": _resolved_policy(a, b),
+                    }
+                )
+            elif str(a.get("harvest_policy") or "") != str(
+                b.get("harvest_policy") or ""
+            ):
+                findings.append(
+                    {
+                        "repo": key,
+                        "kind": "POLICY_DISAGREEMENT",
+                        "severity": "BLOCKING",
+                        "alpha": {"policy": a.get("harvest_policy")},
+                        "beta": {"policy": b.get("harvest_policy")},
+                        "resolution": _resolved_policy(a, b),
+                    }
+                )
+
+        # Ground truth (fail-open when the API is unreachable).
+        if validator is not None:
+            for side_name, side in (("alpha", a), ("beta", b)):
+                if not side:
+                    continue
+                truth = validator.validate(key)
+                if truth.get("exists") is False:
+                    findings.append(
+                        {
+                            "repo": key,
+                            "kind": "REPO_UNRESOLVABLE",
+                            "severity": "BLOCKING",
+                            "source": side_name,
+                            "detail": "GitHub API returned 404",
+                            "resolution": "reject-citation",
+                        }
+                    )
+                    break
+                if truth.get("archived") is True:
+                    findings.append(
+                        {
+                            "repo": key,
+                            "kind": "REPO_ARCHIVED",
+                            "severity": "WARNING",
+                            "detail": "repository is archived",
+                        }
+                    )
+                    break
+                truth_license = _norm_license(truth.get("license"))
+                if (
+                    truth.get("exists")
+                    and truth_license
+                    and not _is_permissive(truth.get("license"))
+                    and _is_permissive(side.get("license"))
+                ):
+                    findings.append(
+                        {
+                            "repo": key,
+                            "kind": "LICENSE_CONTRADICTS_GROUND_TRUTH",
+                            "severity": "BLOCKING",
+                            "source": side_name,
+                            "detail": f"dossier says {side.get('license')}, GitHub says {truth.get('license')}",
+                            "resolution": "clean-room-rebuild-only",
+                        }
+                    )
+                    break
+    return findings

package/runner/refinement.py

@@ -390,3 +390,77 @@ def compute_epistemic_score_from_claims(
         "raw_score": raw_score,
     }
     return epistemic_score, breakdown
+
+
+# Brainstorm's deliverable is hypotheses, not quote-verified facts. Scoring it
+# with the research formula (which counts only verified claims positively)
+# guarantees WARNING_LOW_GROUNDING on a well-formed ideation run.
+BRAINSTORM_MODE_THRESHOLD = 0.5
+
+
+def compute_brainstorm_score_from_claims(
+    claims: Iterable[ClaimWitness],
+    constitution: Optional[Constitution] = None,
+) -> Tuple[float, Dict[str, Any]]:
+    """E(D) variant for brainstorm mode: credit *well-formed* speculation.
+
+    A hypothesis scores when it carries a falsification criterion; an inference
+    when it names its parent claims; negative knowledge earns the usual bonus;
+    verified workspace facts still count. Only rejected (quote-unverified)
+    VERIFIED claims are penalized. This keeps brainstorm honest about grounding
+    without failing a mode whose output is speculative by design.
+    """
+    constitution = constitution or LEGACY_CONSTITUTION
+    counts = {
+        "verified": 0,
+        "rejected": 0,
+        "inferred": 0,
+        "hypotheses": 0,
+        "neg_knowledge": 0,
+    }
+    well_formed = 0
+    for c in claims:
+        if c.status == STATUS_REJECTED or c.tag == "UNVERIFIED_REJECTED":
+            counts["rejected"] += 1
+        elif c.tag == TAG_VERIFIED:
+            counts["verified"] += 1
+        elif c.tag == TAG_INFERRED:
+            counts["inferred"] += 1
+            if c.parent_claims:
+                well_formed += 1
+        elif c.tag == TAG_HYPOTHESIS:
+            counts["hypotheses"] += 1
+            if (c.falsification or "").strip():
+                well_formed += 1
+        elif c.tag == TAG_NEGATIVE_KNOWLEDGE:
+            counts["neg_knowledge"] += 1
+
+    total_assertions = max(
+        1,
+        counts["verified"]
+        + counts["inferred"]
+        + counts["hypotheses"]
+        + counts["rejected"]
+        + counts["neg_knowledge"],
+    )
+    raw_score = (
+        counts["verified"]
+        + well_formed
+        + constitution.neg_bonus * counts["neg_knowledge"]
+        - constitution.reject_penalty * counts["rejected"]
+    ) / total_assertions
+    epistemic_score = max(0.0, min(1.0, round(raw_score, 3)))
+
+    breakdown = {
+        "total_claims_audited": counts["verified"] + counts["rejected"],
+        "verified_passed": counts["verified"],
+        "unverified_rejected": counts["rejected"],
+        "negative_knowledge_count": counts["neg_knowledge"],
+        "inferred_count": counts["inferred"],
+        "hypothesis_count": counts["hypotheses"],
+        "well_formed_count": well_formed,
+        "verified_weight": float(counts["verified"]),
+        "total_assertions": total_assertions,
+        "raw_score": raw_score,
+    }
+    return epistemic_score, breakdown

package/runner/research_swarm.py

@@ -28,6 +28,8 @@ from runner.state_machine import (
     _atomic_write_json,
 )
 from runner.auditor_engine import EpistemicAuditorEngine
+from runner.retrieval_log import current_offset as _retrieval_offset
+from runner.retrieval_log import summarize as _retrieval_summary
 from skills.research_cache.hasher import SourceHasher
 from skills.swarm_config.configure import load_config
 
@@ -268,7 +270,17 @@ class SwarmRunner:
         self.state_machine = ResearchStateMachine(
             base_dir=self.base_dir, mode=self.mode
         )
-        self.auditor = EpistemicAuditorEngine(base_dir=self.base_dir)
+        from runner.auditor_engine import _repo_validation_enabled
+        from runner.darkharvest_claims import RepoValidator
+
+        self.auditor = EpistemicAuditorEngine(
+            base_dir=self.base_dir,
+            # Ground-truth repo checks are for real runs; mock dossiers are
+            # synthetic, so the unit suite must stay offline.
+            repo_validator=RepoValidator(
+                enabled=(not self.mock_mode) and _repo_validation_enabled()
+            ),
+        )
         self.hasher = SourceHasher(base_dir=self.base_dir)
         self.prompts_dir = PROJECT_ROOT / "prompts"
 
@@ -421,7 +433,13 @@ class SwarmRunner:
                 # this the worker operated on the launcher's PWD (observed live:
                 # runner evidence dir 5da7ec/sunny-otter, worker cwd
                 # /home/john/Projects/STC). Keep PWD consistent with cwd.
-                env={**os.environ, "PWD": agent_cwd},
+                # IUMBTEMS_RESEARCH_DIR points agent-invoked skill scripts
+                # (search.py/hasher.py) at this workspace for retrieval telemetry.
+                env={
+                    **os.environ,
+                    "PWD": agent_cwd,
+                    "IUMBTEMS_RESEARCH_DIR": str(self.base_dir),
+                },
                 # stdin MUST be DEVNULL: `opencode run` reads piped stdin to
                 # EOF before starting, and the MCP server's inherited stdin
                 # pipe is held open by the harness — every agent hung forever
@@ -580,14 +598,28 @@ Output ONLY valid JSON representing the scope decomposition conforming to prompt
         return SwarmRunner._parse_json_block(text, require_key="scope_id")
 
     @staticmethod
-    def _load_dossier_file(path: Path) -> Optional[Dict[str, Any]]:
-        """Load a path as a dossier dict, or None when it is not one."""
+    def _load_dossier_file(
+        path: Path, expected_scope: Optional[str] = None
+    ) -> Optional[Dict[str, Any]]:
+        """Load a path as a dossier dict for `expected_scope`, or None.
+
+        A file under the research dir is untrusted input: require a `scope_id`
+        that matches the scope being loaded, so a stray or stub artifact cannot
+        satisfy completion for a different scope.
+        """
         try:
             with open(path, "r", encoding="utf-8") as f:
                 data = json.load(f)
         except (OSError, ValueError):
             return None
-        return data if isinstance(data, dict) and data.get("scope_id") else None
+        if not isinstance(data, dict):
+            return None
+        scope_id = data.get("scope_id")
+        if not scope_id:
+            return None
+        if expected_scope is not None and scope_id != expected_scope:
+            return None
+        return data
 
     def _dossier_candidates(
         self, dossier_path: Path, aliases: Sequence[str]
@@ -639,7 +671,7 @@ Output ONLY valid JSON representing the scope decomposition conforming to prompt
         agent's stdout, then raises a diagnostic error naming where it looked.
         """
         for candidate in self._dossier_candidates(dossier_path, aliases):
-            data = self._load_dossier_file(candidate)
+            data = self._load_dossier_file(candidate, scope_id)
             if data is None:
                 continue
             if candidate != dossier_path:
@@ -1128,7 +1160,9 @@ Output ONLY valid JSON representing the scope decomposition conforming to prompt
             from runner.refinement import load_domain_pack
 
             constitution = load_domain_pack(self.domain_pack)
-        audit_report = self.auditor.audit_scope(scope_id, constitution=constitution)
+        audit_report = self.auditor.audit_scope(
+            scope_id, constitution=constitution, mode=self.mode
+        )
         summary = audit_report["summary"]
         print(
             f"  [Audit Result] Score: {summary['epistemic_score']}/1.0 | Divergence: {summary['divergence_score']} | Verified: {summary['verified_passed']} | Rejected: {summary['unverified_rejected']}"
@@ -1210,6 +1244,11 @@ Output ONLY valid JSON representing the scope decomposition conforming to prompt
         )
         print("=" * 70)
 
+        # Retrieval telemetry baseline: count only events from this run.
+        self._retrieval_offset = _retrieval_offset(self.base_dir)
+        print(f"   {self._retrieval_banner()}")
+        print("=" * 70)
+
         # 1. Orchestrate
         self.orchestrate_objective(objective, frontier_file)
 
@@ -1223,17 +1262,51 @@ Output ONLY valid JSON representing the scope decomposition conforming to prompt
         )
         report_path = self._compile_master_synthesis(objective)
         self.state_machine.update_session_status(SessionStatus.COMPLETED)
+        self._write_orphan_report()
 
         duration = (datetime.now(timezone.utc) - start_time).total_seconds()
+        print(f"   {self._retrieval_banner()}")
         print(f"\n🎉 Swarm run completed in {duration:.1f}s. Report: {report_path}")
 
+    def _write_orphan_report(self) -> None:
+        """Record scope dirs absent from every manifest (mark-only, never delete)."""
+        try:
+            orphans = self.state_machine.find_orphan_scopes()
+        except Exception:  # noqa: BLE001 - hygiene must not fail the run
+            return
+        if not orphans:
+            return
+        path = self.base_dir / "orphans.json"
+        try:
+            path.write_text(json.dumps(orphans, indent=2), encoding="utf-8")
+        except OSError:
+            return
+        print(
+            f"   ⚠️ {len(orphans)} orphaned scope dir(s) not referenced by any "
+            f"manifest -> {path.name} (not deleted)"
+        )
+
+    def _retrieval_banner(self) -> str:
+        """One-line retrieval summary for the current run (issue #3).
+
+        `N queries, M results, K cached` makes an ungrounded run obvious at a
+        glance instead of inferring it from an empty `sources/`.
+        """
+        since = getattr(self, "_retrieval_offset", 0)
+        stats = _retrieval_summary(self.base_dir, since=since)
+        return (
+            f"retrieval: {stats['queries']} queries, {stats['results']} results, "
+            f"{stats['cached']} cached"
+        )
+
     def _collect_scope_totals(
         self, manifest: Dict[str, Any], synthesis_lines: List[str]
-    ) -> Tuple[int, int, List[float]]:
+    ) -> Tuple[int, int, List[float], List[str]]:
         """Fold per-scope audit/synthesis artifacts into running totals."""
         total_verified = 0
         total_rejected = 0
         all_divergences: List[float] = []
+        verdicts: List[str] = []
         for scope in manifest["scopes"]:
             sid = scope["scope_id"]
             scope_dir = self.state_machine.get_scope_dir(sid)
@@ -1246,11 +1319,31 @@ Output ONLY valid JSON representing the scope decomposition conforming to prompt
                 total_verified += summary["verified_passed"]
                 total_rejected += summary["unverified_rejected"]
                 all_divergences.append(summary["divergence_score"])
+                verdicts.append(summary.get("verdict", ""))
 
             if synth_file.exists():
                 synthesis_lines.append(synth_file.read_text(encoding="utf-8"))
                 synthesis_lines.append("\n---\n")
-        return total_verified, total_rejected, all_divergences
+        return total_verified, total_rejected, all_divergences, verdicts
+
+    def _grounding_sentence(self, verified: int, rejected: int, warnings: int) -> str:
+        """Executive summary that matches the audit — never claims certainty it lacks."""
+        if verified == 0 and warnings:
+            return (
+                "⚠️ **WARNING_LOW_GROUNDING**: this run verified 0 primary citations "
+                f"({rejected} claim(s) rejected). Treat the findings below as unverified "
+                "hypotheses, not evidence."
+            )
+        if warnings:
+            return (
+                f"⚠️ {warnings} scope(s) reported WARNING_LOW_GROUNDING. "
+                f"{verified} primary citation(s) verified; {rejected} rejected."
+            )
+        return (
+            f"Compiled by the IUMBTEMS dialectic harness ({self.mode} mode); "
+            f"{verified} primary citation(s) verified against the content-addressed "
+            "source cache."
+        )
 
     def _write_report(self, filename: str, lines: List[str]) -> Path:
         path = self.base_dir / filename
@@ -1269,28 +1362,30 @@ Output ONLY valid JSON representing the scope decomposition conforming to prompt
         }
         title = mode_titles.get(self.mode, "Master Epistemic Research Report")
 
+        # Collect per-scope sections first so the executive summary can reflect
+        # the actual audit verdict instead of asserting certainty we don't have.
+        scope_sections: List[str] = []
+        total_verified, total_rejected, all_divergences, verdicts = (
+            self._collect_scope_totals(manifest, scope_sections)
+        )
+        avg_div = round(sum(all_divergences) / max(1, len(all_divergences)), 2)
+        warnings = sum(1 for v in verdicts if v == "WARNING_LOW_GROUNDING")
+
         synthesis_lines = [
             f"# {title}: {objective}\n",
             f"**Session ID**: `{manifest['session_id']}` | **Mode**: `{self.mode.upper()}` | **Engine**: `{self.engine}` | **Generated**: `{manifest['updated_at']}`\n",
             "## Executive Summary",
-            f"This brief was compiled using the Epistemic Swarm dialectic harness ({self.mode} mode). Every factual statement carries an empirical verification pointer backed by a content-addressed raw document cache.\n",
+            self._grounding_sentence(total_verified, total_rejected, warnings) + "\n",
+            f"{self._retrieval_banner()}\n",
             "## Scope Findings & Dialectic Balance Sheets\n",
+            *scope_sections,
+            "\n## Swarm Epistemic Audit Totals\n",
+            f"- **Total Verified Primary Citations**: `{total_verified}`",
+            f"- **Total Unverified Claims Purged**: `{total_rejected}`",
+            f"- **Mean Swarm Divergence Score**: `{avg_div}`",
+            f"- **Scopes Flagged WARNING_LOW_GROUNDING**: `{warnings}`",
         ]
 
-        total_verified, total_rejected, all_divergences = self._collect_scope_totals(
-            manifest, synthesis_lines
-        )
-
-        avg_div = round(sum(all_divergences) / max(1, len(all_divergences)), 2)
-        synthesis_lines.append("\n## Swarm Epistemic Audit Totals\n")
-        synthesis_lines.append(
-            f"- **Total Verified Primary Citations**: `{total_verified}`"
-        )
-        synthesis_lines.append(
-            f"- **Total Unverified Claims Purged**: `{total_rejected}`"
-        )
-        synthesis_lines.append(f"- **Mean Swarm Divergence Score**: `{avg_div}`")
-
         final_path = self._write_report("final_synthesis.md", synthesis_lines)
 
         # Also write specialized report files for audit/scout/brainstorm/darkharvest.