codegraph-brain 0.14.0__tar.gz → 0.15.0__tar.gz

{codegraph_brain-0.14.0 → codegraph_brain-0.15.0}/.github/workflows/guardian.yml

@@ -90,6 +90,12 @@ jobs:
           GUARDIAN_FEATURES: ${{ vars.GUARDIAN_FEATURES }}
           GUARDIAN_SKEPTIC: ${{ vars.GUARDIAN_SKEPTIC }}
           GUARDIAN_SKEPTIC_MODEL: ${{ vars.GUARDIAN_SKEPTIC_MODEL }}
+          # Static-evidence pass for the skeptic (#401). Wired but not set:
+          # the repository variable is deliberately absent, so enabling it is a
+          # decision made in repo settings rather than a code change nobody
+          # reviews. An unset variable expands to "", which the flag reads as
+          # off — only the literal "1" enables it.
+          GUARDIAN_EVIDENCE: ${{ vars.GUARDIAN_EVIDENCE }}
         run: |
           uv run --frozen python scripts/guardian_review.py \
             --output guardian_report.md \

{codegraph_brain-0.14.0 → codegraph_brain-0.15.0}/.gitignore

@@ -230,3 +230,4 @@ guardian_metrics.jsonl
 *.db-wal
 *.db-shm
 .martian-workspace/
+.guardian-recordings/

codegraph_brain-0.15.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.15.0"
+}

{codegraph_brain-0.14.0 → codegraph_brain-0.15.0}/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [0.15.0](https://github.com/zaebee/codegraph-brain/compare/codegraph-brain-v0.14.1...codegraph-brain-v0.15.0) (2026-08-17)
+
+
+### Features
+
+* **bench:** rebuild frozen finder passes from the corpus, free ([#246](https://github.com/zaebee/codegraph-brain/issues/246)) ([#399](https://github.com/zaebee/codegraph-brain/issues/399)) ([b73f6e0](https://github.com/zaebee/codegraph-brain/commit/b73f6e0d40c5bdc4dadca4acd468d7835670be28))
+* **guardian:** a replay arm that pairs each finding against its own baseline ([#401](https://github.com/zaebee/codegraph-brain/issues/401)) ([#404](https://github.com/zaebee/codegraph-brain/issues/404)) ([b2ab59a](https://github.com/zaebee/codegraph-brain/commit/b2ab59a8d7b5f62a307874b8a0eb9573273fa0ea))
+* **guardian:** let the skeptic see what the checkers say ([#401](https://github.com/zaebee/codegraph-brain/issues/401)) ([#402](https://github.com/zaebee/codegraph-brain/issues/402)) ([af82147](https://github.com/zaebee/codegraph-brain/commit/af821473080bd3a717679e36c90164a43ca07f7b))
+
+## [0.14.1](https://github.com/zaebee/codegraph-brain/compare/codegraph-brain-v0.14.0...codegraph-brain-v0.14.1) (2026-08-16)
+
+
+### Bug Fixes
+
+* **bench:** cutting a release turned the new reachability tests red ([#397](https://github.com/zaebee/codegraph-brain/issues/397)) ([efbca37](https://github.com/zaebee/codegraph-brain/commit/efbca37c13e452fdf7266619b36d86b0e11bb795))
+
 ## [0.14.0](https://github.com/zaebee/codegraph-brain/compare/codegraph-brain-v0.13.0...codegraph-brain-v0.14.0) (2026-08-16)
 
 

{codegraph_brain-0.14.0 → codegraph_brain-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: codegraph-brain
-Version: 0.14.0
+Version: 0.15.0
 Summary: Semantic code graph for AI agents — deterministic FQN resolution, impact analysis and architectural drift gates, exposed over MCP.
 Project-URL: Homepage, https://github.com/zaebee/codegraph-brain
 Project-URL: Repository, https://github.com/zaebee/codegraph-brain

{codegraph_brain-0.14.0 → codegraph_brain-0.15.0}/pyproject.toml

@@ -7,7 +7,7 @@ packages = ["src/cgis"]
 
 [project]
 name = "codegraph-brain"
-version = "0.14.0"
+version = "0.15.0"
 description = "Semantic code graph for AI agents — deterministic FQN resolution, impact analysis and architectural drift gates, exposed over MCP."
 readme = "README.md"
 requires-python = ">=3.12"

{codegraph_brain-0.14.0 → codegraph_brain-0.15.0}/scripts/guardian_bench.py

@@ -166,7 +166,10 @@ async def _judge_recording(
     result = recording.result
     if skeptic is None or not result.findings:
         return result
-    judgements = await judge_all(skeptic[0], result.findings, recording.diff)
+    # The replay path holds a recording, not a checkout: there is no project
+    # root, so no checkers to run. Stated as None rather than defaulted — which
+    # is the point of the argument being required (#401).
+    judgements = await judge_all(skeptic[0], result.findings, recording.diff, evidence=None)
     judged = sum(1 for j in judgements if j is not None)
     return result.model_copy(
         update={

codegraph_brain-0.15.0/scripts/guardian_replay_skeptic.py

@@ -0,0 +1,264 @@
+"""Re-judge a frozen finder pass with evidence, paired against its own baseline (#401).
+
+#402 gave the skeptic the repository's checker output. Whether that changes
+verdicts is unmeasured, and the obvious comparison — run the guardian twice —
+cannot answer it: the finder is sampled, so two runs disagree about *what was
+claimed* before anyone judges anything. Every number would mix the effect with
+the draw.
+
+A recorded finder pass removes that. `guardian.yml` writes `guardian_finder.json`
+on every review, and those findings carry the verdicts of the run that produced
+them. So the baseline already exists: the same findings, the same diff, the same
+skeptic model, judged without evidence. Re-judging them *with* evidence is one
+arm, paired at the level of the individual finding, and it costs one skeptic call
+per finding and no finder call at all.
+
+Evidence is collected in a worktree at the reviewed commit, not in the current
+checkout. The checkers must report on the code the finder actually saw; today's
+tree is a different subject, and a verdict flip caused by that would be
+attributed to the evidence.
+
+Every step refuses rather than guesses. A recording without verdicts has no
+baseline. Evidence that cannot be collected makes this a plain re-run of the
+control arm, which is not the experiment and must not be reported as one.
+"""
+
+import argparse
+import asyncio
+import contextlib
+import json
+import os
+import re
+import subprocess
+import sys
+import tempfile
+from collections import Counter
+from collections.abc import Iterator, Mapping, Sequence
+from pathlib import Path
+
+from cgis.guardian.diff_index import split_diff_by_file
+from cgis.guardian.evidence import Evidence, collect_evidence
+from cgis.guardian.providers.base import BaseProvider
+from cgis.guardian.recording import load_finder_recording
+from cgis.guardian.runner import build_provider, build_skeptic_provider
+from cgis.guardian.skeptic import FindingJudgement, judge_all
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+
+#: Verdicts a recorded finding may carry. A finding outside this set was never
+#: ruled on, so it cannot be a baseline for anything.
+_VERDICTS = frozenset({"confirmed", "refuted", "uncertain"})
+
+#: Words that mark a rationale as resting on the checker output rather than
+#: on the diff. Deliberately broad — a false positive here only inflates the
+#: attributable count, which is the number under scrutiny, so it is reported
+#: beside the total rather than as a conclusion.
+_CHECKER_MENTION = re.compile(r"mypy|ruff|checker|type check|linter|All checks passed", re.I)
+
+
+class NoBaselineError(RuntimeError):
+    """Raised when a recording carries no verdicts to compare against.
+
+    A replay without a baseline produces a column of new verdicts and nothing to
+    subtract, which reads like a result and is not one.
+    """
+
+
+class NoSkepticError(RuntimeError):
+    """Raised when no skeptic is configured, so there is nothing to replay.
+
+    Its own type rather than `NoBaselineError`, whose docstring says "a recording
+    carries no verdicts". Reusing it here would make that sentence false and put
+    a configuration problem and a data problem behind one name — and the two have
+    nothing in common but the moment they are noticed.
+    """
+
+
+class NoEvidenceError(RuntimeError):
+    """Raised when evidence cannot be collected at the reviewed commit.
+
+    Refused rather than degraded: judging without evidence is the control arm,
+    already recorded. Running it again and labelling it the treatment would make
+    the experiment report that evidence changes nothing, which is exactly the
+    conclusion it must not be able to reach by accident.
+    """
+
+
+def baseline_verdicts(path: Path) -> list[str]:
+    """The verdicts of the run that produced this recording, in finding order.
+
+    Read from the raw JSON rather than through `load_finder_recording`, which
+    strips verdicts on purpose — the replay must start from unjudged findings or
+    the skeptic is shown its own previous answers.
+    """
+    raw = json.loads(path.read_text(encoding="utf-8"))
+    # `or {}` rather than a `.get` default: a key present and explicitly null
+    # returns the null, not the default, so `{"result": null}` would reach
+    # `.get("findings")` as None and raise AttributeError. This module promises
+    # `NoBaselineError` for a recording it cannot use; crashing with a type error
+    # instead makes that promise false for one shape of bad input.
+    findings = (raw.get("result") or {}).get("findings") or []
+    verdicts = [f.get("verdict") for f in findings]
+    unruled = [i for i, v in enumerate(verdicts) if v not in _VERDICTS]
+    if not verdicts or unruled:
+        _msg = (
+            f"{path} carries no usable baseline: {len(unruled)} of {len(verdicts)} findings "
+            f"have no verdict. A replay needs the control arm it is being compared against."
+        )
+        raise NoBaselineError(_msg)
+    return [str(v) for v in verdicts]
+
+
+def changed_files(diff: str) -> tuple[str, ...]:
+    """The files the finder was shown, taken from the diff it was shown.
+
+    From the recording rather than from git: the point is to check the same
+    files the claims are about, and a path list re-derived today would drift
+    with the branch.
+    """
+    return tuple(split_diff_by_file(diff))
+
+
+@contextlib.contextmanager
+def worktree_at(ref: str, repo_root: Path) -> Iterator[Path]:
+    """A detached worktree at `ref`, removed on the way out."""
+    with tempfile.TemporaryDirectory(prefix="replay-") as tmp:
+        path = Path(tmp) / "wt"
+        try:
+            subprocess.run(
+                ["git", "worktree", "add", "--detach", str(path), ref],
+                cwd=repo_root,
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+        except subprocess.CalledProcessError as exc:
+            # `CalledProcessError` stringifies to "Command '[...]' returned
+            # non-zero exit status 1" and drops the captured stderr entirely —
+            # the same reasoning `fetch_changed_files` records in
+            # guardian_martian.py:138. Here the lost message is the one that
+            # says whether the ref is unknown, the tree is locked, or the path
+            # exists, and those have three different fixes.
+            _msg = f"Cannot create a worktree at {ref!r}: {exc.stderr.strip() or '(no stderr)'}"
+            raise RuntimeError(_msg) from exc
+        try:
+            yield path
+        finally:
+            subprocess.run(
+                ["git", "worktree", "remove", "--force", str(path)],
+                cwd=repo_root,
+                capture_output=True,
+                check=False,
+            )
+
+
+def flips(baseline: Sequence[str], replayed: Sequence[FindingJudgement | None]) -> Counter[str]:
+    """Counts of `baseline -> replayed`, positionally paired.
+
+    Positional because `judge_all` returns one entry per finding in order and
+    `apply_judgements` relies on that same alignment. A failed call is its own
+    outcome rather than folded into a verdict: absence of a judgement is not a
+    judgement, and counting it as one would let an API outage look like the
+    skeptic changing its mind.
+    """
+    if len(baseline) != len(replayed):
+        _msg = f"{len(baseline)} baseline verdicts against {len(replayed)} replayed; not paired."
+        raise ValueError(_msg)
+    return Counter(
+        f"{was} -> {now.verdict if now is not None else 'call failed'}"
+        for was, now in zip(baseline, replayed, strict=True)
+    )
+
+
+def cites_a_checker(judgement: FindingJudgement | None) -> bool:
+    """Whether the rationale points at the evidence rather than at the diff.
+
+    This is the attributable half. A flip whose reason is "the quoted code does
+    not do what the claim says" is the skeptic working as it always has; a flip
+    whose reason is "ruff reported All checks passed" is the evidence doing
+    something, and only the second supports any claim about this feature.
+    """
+    if judgement is None:
+        return False
+    return bool(_CHECKER_MENTION.search(judgement.rationale or ""))
+
+
+async def replay(
+    recording_path: Path, ref: str, repo_root: Path, env: Mapping[str, str]
+) -> tuple[Counter[str], int]:
+    """Judge the recorded findings again, with evidence; return the flips and citations."""
+    baseline = baseline_verdicts(recording_path)
+    recording = load_finder_recording(recording_path)
+    findings = recording.result.findings
+    if len(findings) != len(baseline):
+        _msg = f"{len(findings)} findings loaded against {len(baseline)} baseline verdicts."
+        raise NoBaselineError(_msg)
+
+    # The worktree and the checkers are blocking, and `replay` is a coroutine.
+    # Nothing else runs on this script's loop today, so the harm is latent rather
+    # than active — but the function is importable and its signature promises a
+    # coroutine, and two minutes of a frozen loop is not something a caller
+    # should have to read the body to discover.
+    evidence = await asyncio.to_thread(_evidence_at, ref, repo_root, recording.diff)
+    if evidence is None:
+        _msg = (
+            f"No evidence could be collected at {ref}. Judging without it repeats the "
+            f"control arm, which is already recorded; reporting that as the treatment "
+            f"would make this experiment conclude that evidence changes nothing."
+        )
+        raise NoEvidenceError(_msg)
+    judgements = await judge_all(skeptic_from(env), findings, recording.diff, evidence=evidence)
+    return flips(baseline, judgements), sum(1 for j in judgements if cites_a_checker(j))
+
+
+def _evidence_at(ref: str, repo_root: Path, diff: str) -> Evidence | None:
+    """Checker output for the recorded files, taken at the reviewed commit.
+
+    The worktree lives only as long as the collection: the checkers read the
+    tree, and nothing afterwards needs it.
+    """
+    with worktree_at(ref, repo_root) as tree:
+        return collect_evidence(tree, changed_files(diff))
+
+
+def skeptic_from(env: Mapping[str, str]) -> BaseProvider:
+    """The configured skeptic, or a refusal naming what is missing.
+
+    The finder is built only to learn its provider name, which decides the
+    skeptic's default opposite — no finder call is ever made here, and that is
+    the whole economy of this arm.
+    """
+    finder, _ = build_provider(env)
+    skeptic = build_skeptic_provider(env, primary=finder.name)
+    if skeptic is None:
+        _msg = (
+            "No skeptic is configured, so there is nothing to replay. Set GUARDIAN_SKEPTIC "
+            "and the matching API key."
+        )
+        raise NoSkepticError(_msg)
+    return skeptic[0]
+
+
+def main() -> int:
+    """Replay one recording and print the paired comparison."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--recording", type=Path, required=True)
+    parser.add_argument("--at", required=True, help="ref or sha the recording was taken at")
+    parser.add_argument("--repo-root", type=Path, default=REPO_ROOT)
+    args = parser.parse_args()
+
+    matrix, cited = asyncio.run(replay(args.recording, args.at, args.repo_root, os.environ))
+    total = sum(matrix.values())
+    print(f"{total} findings re-judged with evidence, paired against their recorded verdicts\n")
+    for transition, count in sorted(matrix.items()):
+        moved = (
+            "" if transition.split(" -> ")[0] == transition.split(" -> ")[1] else "   <- changed"
+        )
+        print(f"  {transition:34} {count:3}{moved}")
+    print(f"\n  rationales citing a checker: {cited}/{total}")
+    print("  (only these are attributable to the evidence; the rest are the skeptic reading code)")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

codegraph_brain-0.15.0/scripts/recordings_from_corpus.py

@@ -0,0 +1,207 @@
+"""Rebuild frozen finder passes from the recorded corpus, without paying a model (#246).
+
+`--replay-finder` isolates the skeptic: the finder is skipped and its recorded
+findings are judged instead, so a skeptic variant costs skeptic calls only. That
+is what makes #246 answerable on a budget — but it needs recordings, and none
+were ever written to disk.
+
+They do not have to be re-run. `benchmarks/guardian/results.jsonl` already holds
+the findings of every scored review, and the diff they were found in is
+regenerable from git, because the benchmark reviews this repository's own PRs
+and every fixture's `base` and `head` resolve locally. So a recording costs one
+`git diff` and nothing else.
+
+**Only rows that had no skeptic are eligible**, and the reason is not
+tidiness. `load_finder_recording` strips verdicts on read, so a judged row would
+not smuggle its verdicts into the next arm — but `apply_judgements` rewrites
+confidence to `round(confidence * 0.9)` on an `uncertain` verdict and the load
+path does not restore it (#279). A recording taken from a judged run therefore
+carries confidences that are not the finder's own, on exactly the subset a
+skeptic experiment is about.
+
+Verified before use rather than after: `tests/unit/test_recordings_from_corpus.py`
+re-scores every rebuilt recording and reproduces the number the corpus recorded —
+72 of 72, under the scoring policy in force when each row was written. The seven
+that differ under today's rule are exactly the seven carrying `ambiguous_hits`,
+which is the #345 policy change that `CURATION.md` says results.jsonl is
+deliberately not rescored for.
+"""
+
+import argparse
+import json
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from cgis.guardian.findings import Finding, ReviewResult
+from cgis.guardian.recording import save_finder_recording
+
+#: Fields `annotate_matches` adds to a stored finding. Stripped on the way back
+#: to a `Finding`, which does not declare them.
+_ANNOTATIONS = ("matched", "verdict", "skeptic_note")
+
+
+class NotAFrozenPassError(RuntimeError):
+    """Raised when a row cannot stand in for an unjudged finder pass.
+
+    Refused rather than cleaned up: a row whose findings were already judged has
+    confidences the skeptic rewrote (#279), and silently accepting it would make
+    two arms of an experiment differ by something nobody chose.
+    """
+
+
+class MissingFixtureError(RuntimeError):
+    """Raised when a row names a PR with no ground-truth fixture, or unresolvable shas.
+
+    The diff is the whole reason a replay needs no worktree. Without one there
+    is nothing to record, and inventing an empty diff would produce a recording
+    that replays as "the finder saw nothing".
+    """
+
+
+def is_frozen_pass(row: dict[str, Any]) -> bool:
+    """True for a scored row whose findings are the finder's own, unjudged."""
+    if "matched" not in row or "precision" not in row:
+        return False
+    if row.get("skeptic_model"):
+        return False
+    return all(f.get("verdict") is None for f in (row.get("findings") or []))
+
+
+def row_key(row: dict[str, Any]) -> str:
+    """`pr@timestamp` — the same identity `guardian_calibrate` writes.
+
+    Used as the recording's filename so a replayed number can be traced to the
+    exact run it came from. Without that, a green replay could mean "reproduced
+    *a* run", which is not the claim being made.
+    """
+    return f"{row['pr']}@{row['timestamp']}"
+
+
+def diff_for(pr: int, bench_dir: Path, repo_root: Path) -> str:
+    """The diff the finder saw, regenerated from the fixture's base and head.
+
+    `base...head`, three dots, mirroring `ContextCollector._diff_range` — the
+    two-dot form would include everything that landed on the base branch after
+    the PR was cut, which is not what any recorded review was shown.
+    """
+    fixture = bench_dir / f"pr-{pr}.yaml"
+    if not fixture.is_file():
+        _msg = f"No ground-truth fixture for pr-{pr} at {fixture}."
+        raise MissingFixtureError(_msg)
+    spec = yaml.safe_load(fixture.read_text(encoding="utf-8"))
+    if not isinstance(spec, dict):
+        _msg = (
+            f"pr-{pr}: {fixture} is not a mapping ({type(spec).__name__}); "
+            f"it names no base or head."
+        )
+        raise MissingFixtureError(_msg)
+    base, head = spec.get("base"), spec.get("head")
+    for name, sha in (("base", base), ("head", head)):
+        if (
+            not sha
+            or subprocess.run(
+                ["git", "rev-parse", "--verify", "--quiet", f"{sha}^{{commit}}"],
+                capture_output=True,
+                cwd=repo_root,
+                check=False,
+            ).returncode
+        ):
+            _msg = (
+                f"pr-{pr}: {name} {sha!r} does not resolve in {repo_root}. Fixture shas are a "
+                f"second population beside the corpora's `guardian_sha`, and PR heads are never "
+                f"ancestors of the trunk because everything here is squash-merged — so they "
+                f"survive only if pinned. Publish it: "
+                f"git push origin {sha}:refs/tags/bench/fixture/pr-{pr}-{name}"
+            )
+            raise MissingFixtureError(_msg)
+    # `check=True` would surface a git failure as CalledProcessError, which is
+    # not what this function promises: every other way it cannot produce a diff
+    # raises MissingFixtureError, and a caller catching that would miss this one.
+    # Both shas are verified above, so a failure here is a broken repository
+    # rather than bad input — but "unlikely" is not the same as "cannot", and a
+    # refusal contract with one escape hatch is not a contract.
+    result = subprocess.run(
+        ["git", "diff", f"{base}...{head}"],
+        capture_output=True,
+        text=True,
+        cwd=repo_root,
+        check=False,
+    )
+    if result.returncode != 0:
+        _msg = (
+            f"pr-{pr}: git diff {base}...{head} exited {result.returncode}: "
+            f"{result.stderr.strip() or '(no stderr)'}"
+        )
+        raise MissingFixtureError(_msg)
+    if not result.stdout.strip():
+        _msg = f"pr-{pr}: {base}...{head} is an empty diff; a review of nothing is not a pass."
+        raise MissingFixtureError(_msg)
+    return result.stdout
+
+
+def recording_for(row: dict[str, Any], diff: str) -> tuple[ReviewResult, str]:
+    """A `ReviewResult` + diff pair equivalent to what the finder produced.
+
+    `summary` is empty because the corpus never stored one. Nothing downstream
+    reads it — the skeptic judges findings against diff hunks and the scorer
+    counts matches — so an empty string is honest about what is known rather
+    than a reconstruction of prose nobody kept.
+    """
+    if not is_frozen_pass(row):
+        _msg = (
+            f"{row_key(row)} is not an unjudged finder pass (skeptic={row.get('skeptic_model')!r})."
+        )
+        raise NotAFrozenPassError(_msg)
+    findings = [
+        Finding.model_validate({k: v for k, v in f.items() if k not in _ANNOTATIONS})
+        for f in (row.get("findings") or [])
+    ]
+    return ReviewResult(
+        findings=findings, summary="", parse_failed=bool(row.get("parse_failed"))
+    ), diff
+
+
+def build(results: Path, out_dir: Path, bench_dir: Path, repo_root: Path) -> list[Path]:
+    """Write one recording per frozen pass; return the paths written."""
+    rows = [
+        json.loads(line)
+        for line in results.read_text(encoding="utf-8").splitlines()
+        if line.strip()
+    ]
+    frozen = [r for r in rows if is_frozen_pass(r)]
+    out_dir.mkdir(parents=True, exist_ok=True)
+    diffs: dict[int, str] = {}
+    written: list[Path] = []
+    for row in frozen:
+        pr = row["pr"]
+        if pr not in diffs:
+            diffs[pr] = diff_for(pr, bench_dir, repo_root)
+        result, diff = recording_for(row, diffs[pr])
+        path = out_dir / f"{row_key(row).replace(':', '-')}.json"
+        save_finder_recording(path, result, diff)
+        written.append(path)
+    return written
+
+
+def main() -> int:
+    """Rebuild every frozen finder pass and report what was written."""
+    repo_root = Path(__file__).resolve().parent.parent
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--results", type=Path, default=repo_root / "benchmarks/guardian/results.jsonl"
+    )
+    parser.add_argument("--out", type=Path, default=repo_root / ".guardian-recordings")
+    parser.add_argument("--bench-dir", type=Path, default=repo_root / "benchmarks/guardian")
+    parser.add_argument("--repo-root", type=Path, default=repo_root)
+    args = parser.parse_args()
+    written = build(args.results, args.out, args.bench_dir, args.repo_root)
+    print(f"{len(written)} recordings written to {args.out}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{codegraph_brain-0.14.0 → codegraph_brain-0.15.0}/src/cgis/guardian/axes.py

@@ -21,11 +21,13 @@ opportunity to invent a false positive, and there noise grew superlinearly
 """
 
 import asyncio
+import os
 
 import structlog
 
 from cgis.guardian.collector import ContextCollector
 from cgis.guardian.core import finder_pass
+from cgis.guardian.evidence import evidence_for
 from cgis.guardian.findings import Finding, ReviewResult, dedup_findings
 from cgis.guardian.prompts import AXIS_GROUPS, PER_AXIS_GROUPS
 from cgis.guardian.providers.base import BaseProvider
@@ -115,7 +117,11 @@ async def run_axis_review(
         return merged
 
     judgements = await judge_all(
-        skeptic_provider, merged.findings, context.get("diff", ""), concurrency
+        skeptic_provider,
+        merged.findings,
+        context.get("diff", ""),
+        concurrency,
+        evidence=await evidence_for(collector, os.environ),
     )
     judged = sum(1 for j in judgements if j is not None)
     if judged == 0:

{codegraph_brain-0.14.0 → codegraph_brain-0.15.0}/src/cgis/guardian/chunked.py

@@ -5,6 +5,8 @@ finder LGTMs large PRs (attention dilution); each chunk gets a small,
 complete world instead — its own diff, full files, and impact graph.
 """
 
+import os
+
 import structlog
 from pydantic import BaseModel
 
@@ -12,6 +14,7 @@ from cgis.guardian.axes import run_axis_review
 from cgis.guardian.chunker import Chunk, build_chunks, split_diff_by_file
 from cgis.guardian.collector import ContextCollector
 from cgis.guardian.core import GuardianReviewer, finder_pass
+from cgis.guardian.evidence import evidence_for
 from cgis.guardian.findings import Finding, ReviewResult, dedup_findings
 from cgis.guardian.providers.base import BaseProvider
 from cgis.guardian.skeptic import (
@@ -182,7 +185,12 @@ async def run_chunked_review(
         "diff": "\n".join(c["diff"] for c in finding_contexts),
         "full_files": "\n\n".join(c["full_files"] for c in finding_contexts if "full_files" in c),
     }
-    judgements = await judge_all(skeptic_provider, merged.findings, skeptic_context["diff"])
+    judgements = await judge_all(
+        skeptic_provider,
+        merged.findings,
+        skeptic_context["diff"],
+        evidence=await evidence_for(collector, os.environ),
+    )
     judged = sum(1 for j in judgements if j is not None)
     if judged == 0:
         log.warning("Every skeptic judgement failed; returning unverified findings.")

{codegraph_brain-0.14.0 → codegraph_brain-0.15.0}/src/cgis/guardian/core.py

@@ -1,9 +1,12 @@
 """Main orchestrator that wires together collector, prompts, and LLM provider."""
 
+import os
+
 import structlog
 from pydantic import ValidationError
 
 from cgis.guardian.collector import ContextCollector
+from cgis.guardian.evidence import evidence_for
 from cgis.guardian.findings import ReviewResult, extract_json, salvage_findings
 from cgis.guardian.prompts import PromptBuilder
 from cgis.guardian.providers.base import BaseProvider
@@ -131,7 +134,11 @@ class GuardianReviewer:
         if self.skeptic_provider is None or not result.findings:
             return result
         judgements = await judge_all(
-            self.skeptic_provider, result.findings, context.get("diff", ""), self.concurrency
+            self.skeptic_provider,
+            result.findings,
+            context.get("diff", ""),
+            self.concurrency,
+            evidence=await evidence_for(self.context_collector, os.environ),
         )
         judged = sum(1 for j in judgements if j is not None)
         if judged == 0: