fix(reviewer): fail closed on empty CodeGraph semantics

.github/workflows/reviewer-ci.yml

@@ -108,14 +108,15 @@ jobs:
           assert runner(["codegraph", "sync"], source_root) == ""
           assert runner(["codegraph", "status"], source_root) == ""
           output = runner(
-              [
-                  "codegraph",
-                  "explore",
-                  "Review blast radius and focused tests for example.ts",
-              ],
+              ["codegraph", "explore", "commercialReadiness"],
               source_root,
           )
-          if "Sandbox copied 1 files" not in output or "## codegraph explore" not in output:
-              raise SystemExit("CodeGraph sandbox smoke output was incomplete")
+          if (
+              "Sandbox copied 1 files" not in output
+              or "## codegraph explore" not in output
+              or "No relevant code found" in output
+              or "export const commercialReadiness = true;" not in output
+          ):
+              raise SystemExit("CodeGraph sandbox smoke did not retrieve the indexed fixture")
           print(output[:2000])
           PY

reviewer/README.md

@@ -36,7 +36,18 @@ they hold regardless of what the model says:
 1. **Strict runs never pass silently.** With `--strict`, a manifest missing its
    diff, changed-file context, current check conclusions, CodeGraph evidence,
    or any requested GitHub evidence source returns a `blocked` verdict that
-   names every gap.
+   names every gap. Production collection emits exactly one wrapper-owned
+   `## codegraph explore` provenance marker and neutralizes any matching marker
+   text returned by raw CodeGraph stdout before retaining it. If raw stdout
+   contains only copies of that marker, collection retains an empty labelled
+   explore section rather than letting the neutralization annotation become
+   semantic evidence. A strict manifest with more than one explore marker is
+   therefore ambiguous and fails closed. Initialization/status banners, an
+   empty labelled explore section, unlabelled concatenated output,
+   `No relevant code found`, truncation/workflow-command annotations without
+   retained semantic bytes, and control/punctuation-only output are not
+   semantic review evidence. Setup/status bytes cannot redefine the
+   wrapper-owned explore boundary.
 2. **MEDIUM-or-higher dependency findings can't ride out on an approve.** An
    unresolved OSV/Trivy/dependency-review finding at MEDIUM+ downgrades an
    approval to `request_changes` with the finding attached — the org rule is
@@ -74,7 +85,7 @@ python -m noema_reviewer --repo ContextualWisdomLab/naruon --pr-number 1039 \
 python -m noema_reviewer --manifest-file manifest.json
 ```
 
-Exit code: `0` for approve/blocked, `2` for request_changes.
+Exit code: `0` for approve, `2` for request_changes, `3` for blocked.
 
 ## Configuration
 
@@ -112,4 +123,4 @@ python -m interrogate -c pyproject.toml noema_reviewer   # 100% docstring gate
 ```
 
 Tests drive the agent with PydanticAI's offline `TestModel`/`FunctionModel` and
-a stub `gh` runner — no network, no secret, no real model.
+a stub `gh` runner — no network, no secret, no real model.

reviewer/noema_reviewer/cli.py

@@ -8,11 +8,12 @@
 from __future__ import annotations
 
 import argparse
+import re
 import sys
-from collections.abc import Callable
+from collections.abc import Callable, Sequence
 
 from .agent import ReviewAgent, build_agent
-from .github_io import fetch_manifest, publish_verdict
+from .github_io import default_codegraph_runner, fetch_manifest, publish_verdict
 from .manifest import ReviewManifest
 from .models import ReviewVerdict, Verdict
 
@@ -21,13 +22,45 @@
 ManifestLoader = Callable[[argparse.Namespace], ReviewManifest]
 Publisher = Callable[[str, int, ReviewVerdict, str, str], str]
 
+CODEGRAPH_EXPLORE_MARKER = "## codegraph explore"
+RAW_CODEGRAPH_EXPLORE_MARKER = "[raw CodeGraph explore marker]"
+
+
+def _semantic_codegraph_runner(args: Sequence[str], source_root: str) -> str:
+    """Attach wrapper-owned explore provenance without trusting raw CodeGraph labels."""
+    output = default_codegraph_runner(args, source_root)
+    if len(args) < 2 or args[1] != "explore":
+        return output
+    stripped = output.strip()
+    if stripped:
+        sanitized = re.sub(
+            re.escape(CODEGRAPH_EXPLORE_MARKER),
+            RAW_CODEGRAPH_EXPLORE_MARKER,
+            output,
+            flags=re.IGNORECASE,
+        )
+        retained_non_marker = "\n".join(
+            line
+            for line in sanitized.splitlines()
+            if line.strip().lower() != RAW_CODEGRAPH_EXPLORE_MARKER.lower()
+        ).strip()
+        if retained_non_marker:
+            return f"{CODEGRAPH_EXPLORE_MARKER}\n{sanitized}"
+        return CODEGRAPH_EXPLORE_MARKER
+    return CODEGRAPH_EXPLORE_MARKER
+
 
 def _load_manifest(args: argparse.Namespace) -> ReviewManifest:
     """Load a manifest from a file when given, else fetch it from GitHub."""
     if args.manifest_file:
         with open(args.manifest_file, encoding="utf-8") as handle:
             return ReviewManifest.model_validate_json(handle.read())
-    return fetch_manifest(args.repo, args.pr_number, source_root=args.source_root)
+    return fetch_manifest(
+        args.repo,
+        args.pr_number,
+        source_root=args.source_root,
+        codegraph_runner=_semantic_codegraph_runner,
+    )
 
 
 def _publish(repo: str, pr_number: int, verdict: ReviewVerdict, head_sha: str, token_source: str) -> str:
@@ -36,7 +69,7 @@ def _publish(repo: str, pr_number: int, verdict: ReviewVerdict, head_sha: str, t
 
 
 def parse_args(argv: list[str]) -> argparse.Namespace:
-    """Parse the reviewer CLI arguments."""
+    """Parse CLI arguments."""
     parser = argparse.ArgumentParser(prog="noema_reviewer", description="Noema independent PR reviewer.")
     parser.add_argument("--repo", default="", help="Target repository in owner/name form.")
     parser.add_argument("--pr-number", type=int, default=0, help="Pull request number.")

reviewer/noema_reviewer/gating.py

@@ -33,6 +33,58 @@
     {"opencode-review", "metadata-only gate evaluation"}
 )
 
+CODEGRAPH_EXPLORE_MARKER = "## codegraph explore"
+
+# These are lifecycle/status banners emitted by CodeGraph collection paths, not
+# semantic review context. The explore provenance wrapper must not promote them
+# merely because they were returned on the explore stdout channel.
+NON_SEMANTIC_CODEGRAPH_EXPLORE_OUTPUTS = frozenset(
+    {
+        "initialized",
+        "synced",
+        "index is up to date",
+        "codegraph initialized; status produced no output.",
+    }
+)
+
+
+def _codegraph_explore_section(codegraph_status: str) -> tuple[str, int, str]:
+    """Return normalized status, marker count, and the sole trusted explore section."""
+    status_lower = codegraph_status.strip().lower()
+    status_lines = status_lower.splitlines()
+    marker_indexes = [
+        index
+        for index, raw_line in enumerate(status_lines)
+        if raw_line.strip() == CODEGRAPH_EXPLORE_MARKER
+    ]
+    marker_count = len(marker_indexes)
+    if marker_count != 1:
+        return status_lower, marker_count, ""
+    return (
+        status_lower,
+        marker_count,
+        "\n".join(status_lines[marker_indexes[0] + 1 :]),
+    )
+
+
+def _has_semantic_codegraph_context(manifest: ReviewManifest) -> bool:
+    """Require retained semantic bytes after exactly one wrapper-owned explore marker."""
+    _, marker_count, explore_section = _codegraph_explore_section(manifest.codegraph_status)
+    if marker_count != 1:
+        return False
+    semantic_lines = explore_section.splitlines()
+    return any(
+        line
+        and line not in NON_SEMANTIC_CODEGRAPH_EXPLORE_OUTPUTS
+        and not line.startswith("[truncated ")
+        and not line.startswith("## codegraph ")
+        and not line.startswith("::")
+        and line.isprintable()
+        and any(character.isalnum() for character in line)
+        for raw_line in semantic_lines
+        if (line := raw_line.strip())
+    )
+
 
 def missing_evidence(manifest: ReviewManifest) -> list[str]:
     """Return human-readable reasons the manifest lacks review-grade evidence."""
@@ -46,13 +98,34 @@ def missing_evidence(manifest: ReviewManifest) -> list[str]:
     if not manifest.check_conclusions:
         reasons.append("missing current GitHub check conclusions")
     codegraph_status = manifest.codegraph_status.strip()
+    codegraph_status_lower, explore_marker_count, final_explore_section = _codegraph_explore_section(
+        codegraph_status
+    )
+    normalized_final_explore = " ".join(
+        line
+        for raw_line in final_explore_section.splitlines()
+        if (line := raw_line.strip())
+        and not line.startswith(("## codegraph ", "::", "[truncated "))
+    )
     if not codegraph_status:
         # A blank/whitespace status is not evidence; treat it as missing so a
         # malformed artifact cannot pass strict mode silently (mirrors the diff
         # check above and the field's own "not supplied" default semantics).
         reasons.append("missing CodeGraph evidence")
-    elif codegraph_status.lower().startswith("unavailable"):
+    elif codegraph_status_lower.startswith("unavailable"):
         reasons.append(manifest.codegraph_status)
+    elif explore_marker_count > 1:
+        # The production wrapper emits exactly one provenance marker. A second
+        # marker can only come from untrusted output or a malformed prepared
+        # manifest, so strict review cannot choose which section is authoritative.
+        reasons.append("CodeGraph semantic query has ambiguous provenance")
+    elif "no relevant code found" in normalized_final_explore:
+        # CodeGraph can initialize and index successfully while returning no
+        # semantic context. The sole provenance-labelled explore section owns
+        # that classification; setup/status output cannot override it.
+        reasons.append("CodeGraph semantic query returned no relevant code")
+    elif not _has_semantic_codegraph_context(manifest):
+        reasons.append("CodeGraph semantic query produced no review context")
     reasons.extend(f"evidence collection failure: {failure}" for failure in manifest.evidence_failures)
     return reasons
 

reviewer/tests/test_cli.py

@@ -138,17 +138,56 @@ def test_load_manifest_from_file(tmp_path) -> None:
     assert loaded.repo == "o/r"
 
 
+def test_semantic_codegraph_runner_labels_explore_output(monkeypatch) -> None:
+    """Production collection labels explore stdout at the command boundary."""
+    monkeypatch.setattr(
+        cli,
+        "default_codegraph_runner",
+        lambda args, source_root: "x.py -> token boundary" if "explore" in args else "initialized",
+    )
+
+    assert cli._semantic_codegraph_runner(
+        ["codegraph", "explore", "review x.py"],
+        "/target",
+    ) == "## codegraph explore\nx.py -> token boundary"
+    assert cli._semantic_codegraph_runner(["codegraph", "status"], "/target") == "initialized"
+
+
+def test_semantic_codegraph_runner_does_not_trust_self_labelled_output(monkeypatch) -> None:
+    """Raw CodeGraph stdout cannot supply the provenance marker trusted by strict review."""
+    labelled = "## codegraph explore\nx.py -> token boundary\n"
+    monkeypatch.setattr(cli, "default_codegraph_runner", lambda args, source_root: labelled)
+
+    assert cli._semantic_codegraph_runner(
+        ["codegraph", "explore", "review x.py"],
+        "/target",
+    ) == (
+        "## codegraph explore\n"
+        "[raw CodeGraph explore marker]\n"
+        "x.py -> token boundary\n"
+    )
+
+
+def test_semantic_codegraph_runner_labels_empty_explore_output(monkeypatch) -> None:
+    """An empty explore result still receives the provenance marker and no synthetic payload."""
+    monkeypatch.setattr(cli, "default_codegraph_runner", lambda args, source_root: "   \n")
+
+    assert cli._semantic_codegraph_runner(["codegraph", "explore", "review x.py"], "/target") == "## codegraph explore"
+
+
 def test_load_manifest_fetches_when_no_file(monkeypatch) -> None:
     """The default loader fetches from GitHub when no file is given."""
     captured = {}
 
-    def fake_fetch(repo, pr_number, *, source_root):
+    def fake_fetch(repo, pr_number, *, source_root, codegraph_runner):
         captured["source_root"] = source_root
+        captured["codegraph_runner"] = codegraph_runner
         return _manifest()
 
     monkeypatch.setattr(cli, "fetch_manifest", fake_fetch)
     assert cli._load_manifest(_args(source_root="/target")).pr_number == 9
     assert captured["source_root"] == "/target"
+    assert captured["codegraph_runner"] is cli._semantic_codegraph_runner
 
 
 def test_publish_adapter_calls_github(monkeypatch) -> None:
@@ -178,4 +217,4 @@ def test_main_runs_with_manifest_file(tmp_path, monkeypatch) -> None:
     manifest_file.write_text(_manifest().model_dump_json())
     monkeypatch.setattr(cli, "build_agent", lambda: FixedAgent(ReviewVerdict(verdict=Verdict.APPROVE, summary="ok")))
     code = cli.main(["--manifest-file", str(manifest_file)])
-    assert code == 0
+    assert code == 0

reviewer/tests/test_codegraph_marker_line_authority.py

@@ -0,0 +1,25 @@
+"""Regression coverage for line-exact CodeGraph provenance markers."""
+
+from noema_reviewer.gating import missing_evidence
+from noema_reviewer.manifest import ChangedFile, CheckConclusion, ReviewManifest
+
+
+def _manifest(codegraph_status: str) -> ReviewManifest:
+    """Build an otherwise-complete manifest for provenance parsing tests."""
+    return ReviewManifest(
+        repo="ContextualWisdomLab/noema",
+        pr_number=546,
+        diff="diff --git a/x.py b/x.py",
+        changed_files=[ChangedFile(path="x.py", content="value = 1")],
+        check_conclusions=[CheckConclusion(name="ci", conclusion="success")],
+        codegraph_status=codegraph_status,
+    )
+
+
+def test_embedded_explore_marker_is_not_wrapper_provenance() -> None:
+    """Only a dedicated marker line may authorize the following semantic payload."""
+    reasons = missing_evidence(
+        _manifest("notice: ## codegraph explore\nx.py -> sensitive_call")
+    )
+
+    assert reasons == ["CodeGraph semantic query produced no review context"]

reviewer/tests/test_codegraph_raw_marker_authority.py

@@ -0,0 +1,36 @@
+"""Regression coverage for wrapper-owned CodeGraph provenance authority."""
+
+from noema_reviewer import cli
+from noema_reviewer.gating import missing_evidence
+from noema_reviewer.manifest import ChangedFile, CheckConclusion, ReviewManifest
+
+
+def _manifest(codegraph_status: str) -> ReviewManifest:
+    """Build an otherwise-complete manifest for the raw-marker authority regression."""
+    return ReviewManifest(
+        repo="ContextualWisdomLab/noema",
+        pr_number=546,
+        diff="diff --git a/x.py b/x.py",
+        changed_files=[ChangedFile(path="x.py", content="value = 1")],
+        check_conclusions=[CheckConclusion(name="ci", conclusion="success")],
+        codegraph_status=codegraph_status,
+    )
+
+
+def test_raw_explore_marker_alone_cannot_become_semantic_context(monkeypatch) -> None:
+    """A sanitized copy of the trust delimiter must not itself satisfy strict evidence."""
+    monkeypatch.setattr(
+        cli,
+        "default_codegraph_runner",
+        lambda args, source_root: "## codegraph explore",
+    )
+
+    retained = cli._semantic_codegraph_runner(
+        ["codegraph", "explore", "review x.py"],
+        "/target",
+    )
+
+    assert retained == "## codegraph explore"
+    assert missing_evidence(_manifest(retained)) == [
+        "CodeGraph semantic query produced no review context"
+    ]