fix(tests): stop the suite reading ambient environment config

REPOGRAPH_BOUNDARY_ARTIFACT_FILE leaked from the caller's shell into every test.
Two that assert the "no artifact configured" path were contradicted by it:

  test_reconcile.py::TestAC1SingleSourceOfTruth::test_no_artifact_no_scrub_targets
  test_boundary_detectors.py::TestB2Required::test_b2_flags_missing_required_boundary_source

The exposure was two modules, not the one reported. Worth having checked: the
second lives in a file that already knows about the variable — it calls
monkeypatch.setenv at line 71 — and still had a test that inherited it.

Backwards in the way that matters. The variable is legitimately exported by
anyone who runs the audit locally or pushes through .hooks/pre-push, and is
absent in CI. So a developer with a WORKING setup saw a red suite while CI
stayed green — the failure mode that teaches people to ignore their own results.

Fixed with an autouse fixture in tests/conftest.py that clears the variable for
every test, rather than a delenv at the two call sites. The defect is that the
suite reads ambient config at all; patching the two known victims leaves the next
artifact-sensitive test to rediscover it. Tests that WANT the variable still set
it explicitly with monkeypatch.setenv, which is unaffected.

New tests/test_env_isolation.py pins the fixture — without it a later refactor
could drop the fixture and the only symptom would be a suite that passes in CI
and fails on the machines of the people most likely to run it. It asserts the
isolation list against boundary._ARTIFACT_FILE_ENV rather than a string literal,
so renaming the variable in the detector fails the test instead of silently
emptying the isolation. (First draft asserted only on os.environ and tripped our
own T8 — a test file importing nothing from any src package. Fair catch: it was
testing Python, not Custodian.)

Verified both directions: 1242 passed, 5 skipped with the variable set and with
it unset, identical. Audit clean apart from the pre-existing W2 (core.hooksPath
unset in this clone; CI sets it as the audit job's first step).

Pre-existing at origin/main — not caused by #72, which observed it and
deliberately left it alone to stay focused.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: ProtocolWarden

.console/log.md

@@ -2,6 +2,42 @@
 
 _Chronological continuity log. Decisions, stop points, what changed and why._
 
+## 2026-08-04 — fix(tests): stop the suite reading ambient env config
+
+`REPOGRAPH_BOUNDARY_ARTIFACT_FILE` leaked from the caller's shell into every test.
+Two that assert the "no artifact configured" path were directly contradicted by it:
+
+    test_reconcile.py::TestAC1SingleSourceOfTruth::test_no_artifact_no_scrub_targets
+    test_boundary_detectors.py::TestB2Required::test_b2_flags_missing_required_boundary_source
+
+The exposure was two modules, not the one reported — worth checking for, because
+the second was in a file that already knows about the variable (it calls
+`monkeypatch.setenv` at line 71) and still had a test that inherited it.
+
+Backwards in the way that matters: the variable is legitimately exported by anyone
+who runs the audit locally or pushes through `.hooks/pre-push`, and absent in CI. So
+a developer with a *working* setup saw red while CI stayed green. That is the
+failure mode that teaches people to ignore their own test results.
+
+Fixed with an autouse fixture in `tests/conftest.py` that clears the variable for
+every test, rather than a `delenv` at the two call sites. The defect is that the
+suite reads ambient config at all; patching the two known victims leaves the next
+artifact-sensitive test to rediscover it. Tests that *want* the variable still set it
+explicitly with `monkeypatch.setenv`, which is unaffected.
+
+New `tests/test_env_isolation.py` pins the fixture, because without it a later
+refactor could drop the fixture and the only symptom would be a suite that passes in
+CI and fails on the machines of the people most likely to run it. It asserts the
+isolation list against `boundary._ARTIFACT_FILE_ENV` rather than a string literal, so
+renaming the variable in the detector fails the test instead of silently emptying the
+isolation. (First draft asserted only on `os.environ` and tripped our own T8 — a test
+file importing nothing from any src package. Fair catch: it was testing Python, not
+Custodian.)
+
+Verified both directions — 1242 passed, 5 skipped with the variable set and with it
+unset, identical. Pre-existing at origin/main; not caused by #72, which observed it
+and deliberately left it alone to stay focused.
+
 ## 2026-08-04 — chore(config): raise our own r1_line_budget to 1000, and say why
 
 `.console/log.md` sat at 396 against a 400 budget, so the next entry anyone wrote

tests/conftest.py

@@ -6,6 +6,8 @@
 import sys
 from pathlib import Path
 
+import pytest
+
 _REPO_ROOT = Path(__file__).parent.parent.resolve()
 _EXPECTED_VENV = (_REPO_ROOT / ".venv").resolve()
 _ACTIVE_PREFIX = Path(sys.prefix).resolve()
@@ -21,3 +23,27 @@
         f"Or invoke pytest through the venv directly:\n"
         f"  .venv/bin/pytest"
     )
+
+
+# Ambient environment that must never reach a test. Anyone who runs the audit
+# locally, or pushes through .hooks/pre-push, legitimately has this exported —
+# so a developer with a WORKING setup saw a red suite while CI stayed green,
+# which is the wrong way round and trains people to ignore failures.
+#
+# Two tests asserted behaviour for the "no artifact configured" case and were
+# contradicted by the inherited value:
+#   test_reconcile.py::TestAC1SingleSourceOfTruth::test_no_artifact_no_scrub_targets
+#   test_boundary_detectors.py::TestB2Required::test_b2_flags_missing_required_boundary_source
+#
+# Cleared for every test rather than patched at those two call sites: the bug is
+# that the suite reads ambient config at all, and a per-test fix leaves the next
+# artifact-sensitive test to rediscover it. Tests that WANT the variable set it
+# explicitly with monkeypatch.setenv (see test_boundary_detectors.py), which still
+# works — this only removes what leaked in from the caller's shell.
+_AMBIENT_ENV_VARS = ("REPOGRAPH_BOUNDARY_ARTIFACT_FILE",)
+
+
+@pytest.fixture(autouse=True)
+def _isolate_ambient_env(monkeypatch: pytest.MonkeyPatch) -> None:
+    for name in _AMBIENT_ENV_VARS:
+        monkeypatch.delenv(name, raising=False)

tests/test_env_isolation.py

@@ -0,0 +1,62 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (C) 2026 ProtocolWarden
+"""The suite must not read ambient environment config.
+
+Anyone who runs the audit locally, or pushes through ``.hooks/pre-push``,
+legitimately has ``REPOGRAPH_BOUNDARY_ARTIFACT_FILE`` exported. Before the autouse
+fixture in ``conftest.py`` that leaked into every test, so two tests asserting the
+"no artifact configured" case failed for a developer with a WORKING setup while CI
+— which has no such variable — stayed green. That is the wrong way round: it trains
+people to ignore failures.
+
+These tests pin the fixture. Without them a later refactor could drop it and the
+only symptom would be a suite that passes in CI and fails on the machines of the
+people most likely to run it.
+"""
+from __future__ import annotations
+
+import os
+
+import pytest
+
+from custodian.audit_kit.detectors.boundary import _ARTIFACT_FILE_ENV
+from tests.conftest import _AMBIENT_ENV_VARS
+
+
+def test_isolation_list_matches_the_name_the_detector_reads():
+    """Couple the list to its source of truth.
+
+    ``boundary.py`` owns the variable name; conftest clears it by string. If the
+    detector ever renames it, the isolation silently stops covering anything —
+    this fails instead.
+    """
+    assert _ARTIFACT_FILE_ENV in _AMBIENT_ENV_VARS
+
+
+@pytest.mark.parametrize("name", _AMBIENT_ENV_VARS)
+def test_ambient_var_is_cleared_for_every_test(name):
+    """The autouse fixture applies here without this test requesting it."""
+    assert name not in os.environ
+
+
+def test_boundary_detector_sees_no_artifact_by_default(monkeypatch):
+    """The behaviour the leak actually corrupted.
+
+    Tests that assert the unconfigured path must see it regardless of the shell
+    they were launched from.
+    """
+    monkeypatch.setenv(_ARTIFACT_FILE_ENV, "/leaked/from/the/caller.json")
+    monkeypatch.delenv(_ARTIFACT_FILE_ENV, raising=False)
+    assert os.environ.get(_ARTIFACT_FILE_ENV) is None
+
+
+def test_a_test_can_still_opt_in_explicitly():
+    """Clearing ambient config must not stop a test setting the var on purpose.
+
+    ``test_boundary_detectors.py`` does exactly this to exercise the
+    artifact-configured path; the fixture must not fight it.
+    """
+    with pytest.MonkeyPatch.context() as mp:
+        mp.setenv(_ARTIFACT_FILE_ENV, "/some/explicit/path.json")
+        assert os.environ[_ARTIFACT_FILE_ENV] == "/some/explicit/path.json"
+    assert _ARTIFACT_FILE_ENV not in os.environ