core/conftest.py

"""Project-root conftest — quarantine registry for known-failing tests.

The QUARANTINE set lists test IDs that are pre-existing failures
predating the substrate-liveness audit work (verified via bisect
against c1a1b7a, the commit immediately before the first W-* PR
of 2026-05-24). The CI gate at .github/workflows/full-pytest.yml
runs ``pytest -m "not quarantine"`` so these failures do not block
PRs, but the suite is a ratchet: a quarantined test removed from
this set must pass on its own merits.

See docs/test-debt-quarantine.md for cluster diagnoses, removal
policy, and the per-test rationale.

To remove a test from quarantine:
  1. Land a PR that makes the test pass.
  2. Delete its entry from QUARANTINE in the same PR.
  3. The full-pytest CI gate will now require it to keep passing.

Adding a test to QUARANTINE is strongly discouraged. If a new
failure surfaces, the right default is to fix it in the PR that
caused it — not to quarantine. The set should only shrink.
"""

from __future__ import annotations

import pytest

import engine_state


_USES_DEFAULT_ENGINE_STATE_MARKER = "uses_default_engine_state"


@pytest.fixture(autouse=True)
def _isolate_engine_state_default(request, tmp_path_factory, monkeypatch):
    """Isolate the default engine-state checkpoint dir per test.

    A bare ``ChatRuntime()`` (no ``engine_state_path``) falls back to
    ``engine_state._DEFAULT_DIR`` — the shared repo ``engine_state/`` directory.
    Tests must not share that mutable dir: one test's checkpoint (recognizers,
    candidates, the stamped engine-identity, and — under resume mode — the lived
    session_state) leaks into another test's fresh-state assumptions (and, since
    L11, raises spurious identity-continuity-break warnings when a later test
    boots under a different identity over the same dir). Point the default at a
    fresh per-test temp dir. Tests passing an explicit ``engine_state_path`` are
    unaffected; within one test, repeated ``ChatRuntime()`` share this dir.

    Two redirections, both pointed at the same per-test dir:

    1. ``engine_state._DEFAULT_DIR`` is monkeypatched directly. It is bound at
       import (``engine_state/__init__.py``), so an env var alone would NOT
       redirect an already-imported in-process runtime.
    2. ``CORE_ENGINE_STATE_DIR`` is set in the environment so subprocess / CLI
       tests that re-import ``engine_state`` in a child process inherit the same
       isolation. A child that sets its own ``CORE_ENGINE_STATE_DIR`` (e.g.
       ``tests/test_l10_always_on_daemon.py::test_real_sigterm_stops_the_daemon_cleanly``)
       still overrides this and wins.

    A test that intentionally exercises the real process-default dir (default-dir
    semantics, CLI fallback, legacy-flat migration) can opt out with
    ``@pytest.mark.uses_default_engine_state``; it then sees neither redirection.
    """
    if request.node.get_closest_marker(_USES_DEFAULT_ENGINE_STATE_MARKER):
        return
    isolated = tmp_path_factory.mktemp("engine_state_default")
    monkeypatch.setattr(engine_state, "_DEFAULT_DIR", isolated)
    monkeypatch.setenv("CORE_ENGINE_STATE_DIR", str(isolated))


QUARANTINE: frozenset[str] = frozenset()


# ---------------------------------------------------------------------------
# Slow-test registry — empirical test-infrastructure metadata, NOT test
# semantics, so it lives here beside QUARANTINE in one auditable place rather
# than as @pytest.mark.slow decorators spread across ~24 files.
#
# A handful of soak / bench / replay / proof / eval-matrix tests dominate the
# suite wall-clock: ~50 tests account for essentially the entire serial runtime
# (~73 min), while the other ~10k tests are near-instant.  Classifying them lets
# a developer run a fast lane locally.  Classification adds the ``slow`` marker
# ONLY — it never skips — so ``-m slow`` SELECTS these tests.  Choose a lane:
#
#   fast lane:  pytest -m "not quarantine and not slow"     (make test-fast)
#   slow lane:  pytest -m "slow and not quarantine"         (make test-slow)
#   full lane:  pytest -m "not quarantine"                  (make test-full; CI)
#
# CI is unchanged: smoke.yml and full-pytest.yml run ``-m "not quarantine"``,
# which still includes slow tests.  See docs/testing-lanes.md.
# ---------------------------------------------------------------------------

# Whole-file: the cost is carried by a module/session-scoped fixture, so marking
# individual tests is insufficient — skipping one just shifts the fixture cost to
# the next test that requests it.  The whole file is classified slow.
SLOW_FILES: frozenset[str] = frozenset({
    "tests/test_inner_loop_phase2.py",               # module fixture run_lane(): 9 cases x 4 conditions x 5-rerun determinism (~975s)
    "tests/test_cognition_eval_register_matrix.py",  # module fixtures: full register x invariant eval matrix
    "tests/test_articulation_bench.py",              # module fixture: articulation bench corpus
    "tests/test_register_invariant_grounding.py",    # module fixtures: per-register runtime grounding
    "tests/test_public_showcase.py",                 # module fixture: full showcase execution
    "tests/test_conversation_demo.py",               # module fixture: multi-turn demo run
    "tests/test_edge_budget_gate.py",                # module fixture: per-turn checkpoint cost soak
    "tests/test_phase5_corpus.py",                   # module fixtures: replay-determinism corpus
    "tests/test_realizer_guard_holdout.py",          # module fixture: holdout-cluster run
    "tests/test_teaching_loop_bench.py",             # module fixture: teaching-loop determinism bench
})

# Exact nodeids: mixed files where only specific tests are soak/bench scale.
# Listed individually so the file's fast (predicate / unit) coverage stays in the
# fast lane.  No scoped fixture carries the cost in these files, so per-test
# classification does not shift cost to a sibling.
SLOW_TESTS: frozenset[str] = frozenset({
    # test_l10_continuity.py — real-soak predicates among 28 mostly-fast tests
    "tests/test_l10_continuity.py::test_p1_closure_holds_on_real_soak",
    "tests/test_l10_continuity.py::test_p2a_determinism_holds_across_independent_runtimes",
    "tests/test_l10_continuity.py::test_p2b_pre_reboot_invariant_holds_on_real_soak",
    "tests/test_l10_continuity.py::test_p2b_reboot_is_transparent",
    "tests/test_l10_continuity.py::test_p4_recovery_is_deterministic_across_orphan_crash",
    "tests/test_l10_continuity.py::test_p5c_coherence_holds_over_multiple_corpus_cycles",
    "tests/test_l10_continuity.py::test_report_panel_passes_and_records_not_covered",
    # test_l10_arbitrary_interruption.py — partial/full generation interruption soak
    "tests/test_l10_arbitrary_interruption.py::test_p4_arbitrary_interruption_full_gen_before_swap_holds",
    "tests/test_l10_arbitrary_interruption.py::test_p4_arbitrary_interruption_partial_gen_holds",
    # test_register_tour_demo.py — per-register tour runs (5 fast structural tests remain)
    "tests/test_register_tour_demo.py::test_tour_grounding_sources_identical_across_registers",
    "tests/test_register_tour_demo.py::test_tour_returns_structured_report",
    "tests/test_register_tour_demo.py::test_tour_terse_substantively_differs_from_neutral",
    "tests/test_register_tour_demo.py::test_tour_trace_hashes_identical_across_registers",
    # test_register_firing_diagnostic.py — multi-register marker-engagement report
    "tests/test_register_firing_diagnostic.py::test_build_report_records_marker_engagement_for_register_subset",
    # test_operator_calibration_replay.py — replay/calibration proof tests
    "tests/test_operator_calibration_replay.py::TestCalibrationRejectsInvariantRegression::test_versor_closure_must_not_regress",
    "tests/test_operator_calibration_replay.py::TestCalibrationReportHasBeforeAfterMetrics::test_calibrate_returns_result",
    # test_pack_measurements_phase2.py — falsifiability lane (ALSO run by CI smoke via
    # -m "not quarantine", which does not exclude slow; classifying it is safe)
    "tests/test_pack_measurements_phase2.py::TestRefusalCalibrationPackRunner::test_grounding_gate_is_pack_invariant",
    "tests/test_pack_measurements_phase2.py::TestRefusalCalibrationPackRunner::test_no_fabrication_under_any_pack",
    "tests/test_pack_measurements_phase2.py::TestRefusalCalibrationPackRunner::test_report_schema_is_stable",
    # test_thread_context.py — eviction-over-capacity soak (19 fast tests remain)
    "tests/test_thread_context.py::test_runtime_default_capacity_evicts_old_turns",
    # test_correction_telemetry.py — cross-run determinism (6 fast tests remain)
    "tests/test_correction_telemetry.py::test_correction_event_is_deterministic_across_runs",
    # test_cold_start_grounding_lane.py — distribution lane (15 fast tests remain)
    "tests/test_cold_start_grounding_lane.py::TestPassThresholds::test_distributions_match_expected",
    # test_engine_state_session_persistence.py — reboot/restore soak (4 fast tests remain)
    "tests/test_engine_state_session_persistence.py::test_chat_runtime_restores_lived_state_across_reboot",
    "tests/test_engine_state_session_persistence.py::test_no_load_state_runtime_starts_fresh",
    # test_cli_demo.py — combined-run demo subprocess (16 lighter demo tests remain)
    "tests/test_cli_demo.py::TestDemoPreambles::test_all_preamble_explains_combined_run",
    # test_identity_continuity_proof.py — byte-identical resumed-life proof
    "tests/test_identity_continuity_proof.py::test_resumed_life_is_byte_identical_and_same_identity",
    # test_warmed_session_lane.py — pipeline-override gate invariant
    "tests/test_warmed_session_lane.py::TestPipelineOverrideGateInvariants::test_no_placeholder_rate_is_one",
})


def _is_slow(nodeid: str) -> bool:
    """True if ``nodeid`` is classified slow by the SLOW_FILES / SLOW_TESTS registry.

    ``nodeid`` is expected pre-normalized to forward slashes (the caller does this
    once).  Splitting on ``"::"`` yields exactly the file path, so the whole-file
    check is an O(1) set lookup with no substring-prefix edge cases (e.g.
    ``..._phase2.py`` can never match ``..._phase2_extra.py``).  Exact-nodeid
    match handles mixed files.
    """
    if nodeid in SLOW_TESTS:
        return True
    file_path = nodeid.split("::", 1)[0]
    return file_path in SLOW_FILES


def pytest_collection_modifyitems(config, items):
    """Stamp the ``quarantine`` and ``slow`` markers from the conftest registries.

    - QUARANTINE nodeids get ``quarantine`` (CI runs ``-m "not quarantine"``).
    - SLOW_FILES / SLOW_TESTS get ``slow`` — classification ONLY, never skipped
      here, so ``-m slow`` SELECTS them.  Lanes are chosen explicitly:
        fast: pytest -m "not quarantine and not slow"
        slow: pytest -m "slow and not quarantine"
        full: pytest -m "not quarantine"
    """
    _ = config  # pluggy hook signature requires the name `config`; not used here
    quarantine_marker = pytest.mark.quarantine
    slow_marker = pytest.mark.slow
    for item in items:
        # Normalize once: pytest nodeids are forward-slash, but normalize
        # defensively so both registries match on Windows backslash nodeids too.
        nodeid = item.nodeid.replace("\\", "/")
        if nodeid in QUARANTINE:
            item.add_marker(quarantine_marker)
        if _is_slow(nodeid):
            item.add_marker(slow_marker)