maintainability-agent 2.1.0__tar.gz → 2.2.0__tar.gz

{maintainability_agent-2.1.0/src/maintainability_agent.egg-info → maintainability_agent-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maintainability-agent
-Version: 2.1.0
+Version: 2.2.0
 Summary: Maintainability gate and AI remediation prompt generator for CI.
 Author: Marshall Guillory
 License: MIT
@@ -44,7 +44,7 @@ Dynamic: license-file
 **A deterministic, offline maintainability audit whose output is a _bounded
 work order_ for an AI coding agent** — a copy-paste prompt, per finding, that
 says *fix exactly these and refactor nothing else*. Chat-primary; CLI for CI.
-Version **2.1.0**.
+Version **2.2.0**.
 
 **Languages parsed:** Python, Java, C, C++, C#, Fortran (free-form *and*
 fixed-form), and the JS/TS family — each by a scanner written for it, and

{maintainability_agent-2.1.0 → maintainability_agent-2.2.0}/README.md

@@ -5,7 +5,7 @@
 **A deterministic, offline maintainability audit whose output is a _bounded
 work order_ for an AI coding agent** — a copy-paste prompt, per finding, that
 says *fix exactly these and refactor nothing else*. Chat-primary; CLI for CI.
-Version **2.1.0**.
+Version **2.2.0**.
 
 **Languages parsed:** Python, Java, C, C++, C#, Fortran (free-form *and*
 fixed-form), and the JS/TS family — each by a scanner written for it, and

{maintainability_agent-2.1.0 → maintainability_agent-2.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "maintainability-agent"
-version = "2.1.0"
+version = "2.2.0"
 description = "Maintainability gate and AI remediation prompt generator for CI."
 readme = "README.md"
 # 3.11, not 3.10. `_discovery`, `_pillars` and `_runner` all import

{maintainability_agent-2.1.0 → maintainability_agent-2.2.0/src/maintainability_agent.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maintainability-agent
-Version: 2.1.0
+Version: 2.2.0
 Summary: Maintainability gate and AI remediation prompt generator for CI.
 Author: Marshall Guillory
 License: MIT
@@ -44,7 +44,7 @@ Dynamic: license-file
 **A deterministic, offline maintainability audit whose output is a _bounded
 work order_ for an AI coding agent** — a copy-paste prompt, per finding, that
 says *fix exactly these and refactor nothing else*. Chat-primary; CLI for CI.
-Version **2.1.0**.
+Version **2.2.0**.
 
 **Languages parsed:** Python, Java, C, C++, C#, Fortran (free-form *and*
 fixed-form), and the JS/TS family — each by a scanner written for it, and

{maintainability_agent-2.1.0 → maintainability_agent-2.2.0}/src/maintainability_agent.egg-info/SOURCES.txt

@@ -33,6 +33,7 @@ src/maintainability_audit/_evidence_view.py
 src/maintainability_audit/_finding_match.py
 src/maintainability_audit/_first_run.py
 src/maintainability_audit/_formula.py
+src/maintainability_audit/_gates.py
 src/maintainability_audit/_generic.py
 src/maintainability_audit/_grant_ledger.py
 src/maintainability_audit/_history_view.py
@@ -62,6 +63,7 @@ src/maintainability_audit/_ranges_csharp.py
 src/maintainability_audit/_ranges_fortran.py
 src/maintainability_audit/_ranges_java.py
 src/maintainability_audit/_ranges_js.py
+src/maintainability_audit/_ratchet.py
 src/maintainability_audit/_recurrence.py
 src/maintainability_audit/_runner.py
 src/maintainability_audit/_safe_write.py
@@ -187,6 +189,7 @@ tests/test_declared_authorship.py
 tests/test_declared_imports.py
 tests/test_derivation_mix.py
 tests/test_determinism.py
+tests/test_dimension_ratchet.py
 tests/test_direct_runner_availability_class.py
 tests/test_discovery.py
 tests/test_doc_claims.py

{maintainability_agent-2.1.0 → maintainability_agent-2.2.0}/src/maintainability_audit/__init__.py

@@ -1,3 +1,3 @@
 """Maintainability Audit CI."""
 
-__version__ = "2.1.0"
+__version__ = "2.2.0"

maintainability_agent-2.2.0/src/maintainability_audit/_gates.py

@@ -0,0 +1,122 @@
+"""What happens after the audit and before the exit code.
+
+Split from `cli.py` when it crossed this project's 500-line file gate —
+the same reason `_mcp_setup`, `_adapters` and `test_architecture` were
+split before it.
+
+The split is not arbitrary. Everything here composes from the **finished
+report**: whether the diff obeyed its work order, whether a dimension
+slipped since the last comparable scan, and what those two facts mean for
+the process exit code. None of it measures a tree and none of it may reach
+scoring — a fact about an agent's behaviour, or about the difference
+between two scans, is not evidence about the code's condition.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from .baseline import findings_not_in_baseline
+from .git_tools import added_lines, changed_paths
+
+
+def attach_conformance(args: argparse.Namespace, report: dict) -> None:
+    """Record how the diff relates to the work order, when asked.
+
+    Assembly, not scoring: the record is attached to the report and reaches
+    no dimension, because whether a diff was obedient is a fact about an
+    agent's behaviour and not evidence about the code's condition.
+    """
+    if not args.conformance:
+        return
+    from ._conformance import scope_conformance
+
+    root = Path(report["root"])
+    changed = changed_paths(root, args.conformance)
+    added = added_lines(root, args.conformance)
+    report["scope_conformance"] = scope_conformance(
+        report, changed, args.conformance, added
+    )
+
+
+def attach_ratchet(report: dict, history_path: Path) -> None:
+    """Record whether any category slipped since the last comparable scan."""
+    from ._ratchet import dimension_ratchet
+    from ._scan_history import read_history
+
+    if not history_path.exists():
+        return
+    report["dimension_ratchet"] = dimension_ratchet(read_history(history_path))
+
+
+def _attach_post_audit_records(
+    args: argparse.Namespace, report: dict, history_path: Path
+) -> None:
+    """Records composed from the finished report, before it is rendered.
+
+    Both read the report rather than the tree, and neither reaches scoring:
+    whether a diff obeyed its work order, and whether a dimension slipped
+    since the last comparable scan, are facts about a change and its
+    history — not evidence about the code's condition.
+    """
+    attach_conformance(args, report)
+    attach_ratchet(report, history_path)
+
+
+def _conformance_exit(args: argparse.Namespace, report: dict) -> int:
+    """0 to continue; otherwise the exit code the conformance gate demands."""
+    if not args.fail_on_out_of_scope:
+        return 0
+    record = report.get("scope_conformance")
+    if record is None:
+        print("--fail-on-out-of-scope needs --conformance REVSPEC", file=sys.stderr)
+        return 2
+    # `clean`, not `conformant`: staying in scope while silencing the finding
+    # is the evasion the pairing exists to catch, and a gate that accepted it
+    # would be satisfied by the thing it guards against.
+    return 0 if record["clean"] else 1
+
+
+def _regression_exit(args: argparse.Namespace, report: dict) -> int:
+    """0 to continue; otherwise the exit code the ratchet demands."""
+    if not args.fail_on_regression:
+        return 0
+    ratchet = report.get("dimension_ratchet")
+    if ratchet is None:
+        print("--fail-on-regression needs a recorded history (--record-history)",
+              file=sys.stderr)
+        return 2
+    # A run that could not compare does not pass quietly: exiting 0 where the
+    # question was never asked is the "absence read as a pass" shape.
+    #
+    # The reason is not interpolated — it derives from recorded scan history,
+    # and code scanning is right that history fields have no business in a log
+    # line. It stays in the report, which a caller reads deliberately.
+    # Suppressing that alert was refused: this release ships the check that
+    # treats a suppression as a finding rather than a fix.
+    if not ratchet["comparable"]:
+        print("no comparable scan for --fail-on-regression; see "
+              "dimension_ratchet.reason in the report", file=sys.stderr)
+        return 2
+    return 1 if ratchet["regressed"] else 0
+
+
+def audit_exit_code(args: argparse.Namespace, report: dict) -> int:
+    if args.fail_on_new:
+        # Structured matching, never a label-set difference: a label
+        # changes under `git mv` and same-name reorder, and failing a
+        # build over either is a false report about the change.
+        root = Path(report["root"])
+        if findings_not_in_baseline(report, args.baseline, root):
+            return 1
+    if args.fail_on_gate and report["hard_gate_failures"]:
+        return 1
+    conformance = _conformance_exit(args, report)
+    if conformance:
+        return conformance
+    regression = _regression_exit(args, report)
+    if regression:
+        return regression
+    return 0

maintainability_agent-2.2.0/src/maintainability_audit/_ratchet.py

@@ -0,0 +1,109 @@
+"""Did any dimension get worse than the last comparable scan?
+
+The third mechanism behind the attestation. `--fail-on-new` already catches
+a finding that clears and returns, using structured identity so a rename is
+not a new finding. What nothing caught is the slower failure: a change that
+improves one dimension while quietly regressing another. Both scans are
+green by every existing gate, the overall estimate can even rise, and the
+thing that got worse is never named.
+
+**The comparison is only honest inside one segment.** History is already
+split wherever the instrument changed — a different calibration constant, a
+different analyzer population — because two scans taken with different
+instruments cannot be subtracted. `_scan_history.segments` owns that rule,
+and this module refuses rather than reaching across a break. A ratchet that
+compared a 1.x score to a 2.0 score would have reported every repository on
+earth as catastrophically regressed on the day the corpus was extended, and
+it would have been the ratchet that was wrong.
+
+So there are three outcomes, not two: **held**, **regressed**, and **not
+comparable**. The third is not a pass. It says the question could not be
+asked, which is what a reader needs in order to know they are not being
+reassured by silence.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ._scan_history import ScanRecord, segments
+
+#: Scores are reported to one decimal, so a difference below this is the
+#: rounding boundary rather than a movement. Named rather than inlined
+#: because it is a judgment: too tight and every scan trips on noise, too
+#: loose and a real slide hides under the threshold.
+TOLERANCE = 0.05
+
+
+def _series(record: ScanRecord, field: str) -> dict[str, float]:
+    values = getattr(record, field, None) or {}
+    return {
+        name: float(value) for name, value in values.items()
+        if isinstance(value, (int, float))
+    }
+
+
+def _regressions(
+    previous: ScanRecord, current: ScanRecord, field: str
+) -> list[dict[str, Any]]:
+    """Names that dropped, with the size of the drop."""
+    before, after = _series(previous, field), _series(current, field)
+    found = []
+    for name, was in sorted(before.items()):
+        # A name the current scan does not carry is not a regression: the
+        # aspect became unmeasurable, which the evidence model already
+        # reports as `Unknown` rather than as a zero. Scoring it as a drop
+        # to nothing would turn withheld evidence into a failure, which is
+        # the exact inversion P3 forbids.
+        if name not in after:
+            continue
+        now = after[name]
+        if was - now > TOLERANCE:
+            found.append({
+                "name": name, "was": round(was, 2),
+                "now": round(now, 2), "drop": round(was - now, 2),
+            })
+    return found
+
+
+def dimension_ratchet(records: list[ScanRecord]) -> dict[str, Any]:
+    """Compare the newest scan with the previous comparable one.
+
+    `comparable` is the load-bearing field. False means the two scans sit
+    either side of an instrument change, or there is no earlier scan at
+    all — in both cases the question was not asked, and a caller must not
+    read that as "nothing regressed".
+    """
+    if len(records) < 2:
+        return {
+            "comparable": False,
+            "reason": "no earlier scan to compare against",
+            "regressed": [],
+        }
+
+    latest = segments(records)[-1]
+    if len(latest.records) < 2:
+        return {
+            "comparable": False,
+            "reason": (
+                latest.break_reason
+                or "the previous scan was taken with a different instrument"
+            ),
+            "regressed": [],
+        }
+
+    previous, current = latest.records[-2], latest.records[-1]
+    categories = _regressions(previous, current, "categories")
+    aspects = _regressions(previous, current, "aspects")
+
+    return {
+        "comparable": True,
+        "against": getattr(previous, "commit", None),
+        "categories": categories,
+        "aspects": aspects,
+        # Categories only. An aspect can move while the category holding it
+        # holds, and failing on every aspect wobble makes the gate noise.
+        # Aspects are reported so a reader can see what moved underneath.
+        "regressed": categories,
+        "held": not categories,
+    }

{maintainability_agent-2.1.0 → maintainability_agent-2.2.0}/src/maintainability_audit/cli.py

@@ -14,6 +14,10 @@ from ._first_run import (
     maybe_prompt_first_run,
     maybe_prompt_test_command,
 )
+from ._gates import (
+    _attach_post_audit_records,
+    audit_exit_code,
+)
 from ._mcp_audit import record_scan_and_attach
 from ._safe_write import write_artifact
 from ._scan_history import (
@@ -24,7 +28,6 @@ from ._user_config import mark_repo_seen
 from ._work_order import SELECTABLE, combined_delta, select
 from .baseline import (
     finding_fingerprints,
-    findings_not_in_baseline,
     load_baseline,
     write_baseline,
 )
@@ -36,7 +39,7 @@ from .config import (
     load_config,
     repository_path,
 )
-from .git_tools import added_lines, changed_paths
+from .git_tools import changed_paths
 from .instructions import (
     INSTRUCTION_TARGETS,
     UnknownTarget,
@@ -65,6 +68,14 @@ def _add_gate_arguments(parser: argparse.ArgumentParser) -> None:
              "else'; without this the bound is an instruction nothing checks. "
              "Reports only unless --fail-on-out-of-scope is passed.",
     )
+    parser.add_argument(
+        "--fail-on-regression", action="store_true",
+        help="Exit 1 when any scoring category is lower than the previous "
+             "comparable scan. Reads the recorded history, and refuses to "
+             "compare across an instrument change rather than reporting a "
+             "false regression: two scans taken under different calibration "
+             "cannot be subtracted.",
+    )
     parser.add_argument(
         "--fail-on-out-of-scope", action="store_true",
         help="With --conformance, exit 1 when the diff touched files the work "
@@ -226,48 +237,6 @@ def write_outputs(args: argparse.Namespace, report: dict, rendered: str) -> None
                        json.dumps(report_to_sarif(report), indent=2) + "\n", json_artifact=True)
 
 
-def attach_conformance(args: argparse.Namespace, report: dict) -> None:
-    """Record how the diff relates to the work order, when asked.
-
-    Assembly, not scoring: the record is attached to the report and reaches
-    no dimension, because whether a diff was obedient is a fact about an
-    agent's behaviour and not evidence about the code's condition.
-    """
-    if not args.conformance:
-        return
-    from ._conformance import scope_conformance
-
-    root = Path(report["root"])
-    changed = changed_paths(root, args.conformance)
-    added = added_lines(root, args.conformance)
-    report["scope_conformance"] = scope_conformance(
-        report, changed, args.conformance, added
-    )
-
-
-def audit_exit_code(args: argparse.Namespace, report: dict) -> int:
-    if args.fail_on_new:
-        # Structured matching, never a label-set difference: a label
-        # changes under `git mv` and same-name reorder, and failing a
-        # build over either is a false report about the change.
-        root = Path(report["root"])
-        if findings_not_in_baseline(report, args.baseline, root):
-            return 1
-    if args.fail_on_gate and report["hard_gate_failures"]:
-        return 1
-    if args.fail_on_out_of_scope:
-        record = report.get("scope_conformance")
-        if record is None:
-            print("--fail-on-out-of-scope needs --conformance REVSPEC", file=sys.stderr)
-            return 2
-        # `clean`, not `conformant`: staying in scope while silencing the
-        # finding is the evasion the pairing exists to catch, and a gate
-        # that accepted it would be satisfied by the thing it guards against.
-        if not record["clean"]:
-            return 1
-    return 0
-
-
 def _analyzers_resolved(args: argparse.Namespace, config: dict) -> bool:
     """Whether the pool runs: flags beat config, config beats nothing.
 
@@ -325,7 +294,6 @@ def _install_skill_action(args: argparse.Namespace) -> int:
     return 0
 
 
-
 def _target_paths(pairs: list[str] | None) -> dict[str, str]:
     """`TARGET=PATH` arguments, as a mapping.
 
@@ -429,7 +397,7 @@ def main(argv: list[str] | None = None) -> int:
                            record=bool(record), want_targets=bool(args.prompt_output))
     # Before rendering, so the record is in the report every presentation
     # and every consumer reads, rather than only in the exit code.
-    attach_conformance(args, report)
+    _attach_post_audit_records(args, report, history_path)
     rendered = _render_presentation(args, report, history_path)
     write_outputs(args, report, rendered)
     mark_repo_seen(root)  # completed audit: not a first run now, whatever the gate says (D13)

{maintainability_agent-2.1.0 → maintainability_agent-2.2.0}/src/maintainability_audit/config.py

@@ -11,7 +11,7 @@ from ._config_defaults import DEFAULT_CONFIG, DEFAULT_IDIOM_GROUPS
 # still the door every caller comes through.
 __all__ = ["DEFAULT_CONFIG", "DEFAULT_IDIOM_GROUPS", "PROJECT_URL", "VERSION"]
 
-VERSION = "2.1.0"
+VERSION = "2.2.0"
 
 PROJECT_URL = "https://github.com/marshallguillory86/maintainability-agent"
 

maintainability_agent-2.2.0/tests/test_dimension_ratchet.py

@@ -0,0 +1,155 @@
+"""A change that improves one dimension while regressing another.
+
+`--fail-on-new` catches a finding that clears and returns. Nothing caught
+the slower failure: modularity up, testability quietly down, both scans
+green by every existing gate, and the thing that got worse never named.
+
+The judgment that matters here is not the subtraction. It is **when
+subtracting is allowed at all**. Two scans taken with different
+instruments — a different calibration constant, a different analyzer
+population — cannot be compared, and `_scan_history.segments` already owns
+that rule for the trend charts. A ratchet that ignored it would have
+reported every repository on earth as catastrophically regressed on the day
+2.0.0 extended the corpus and moved `CALIBRATION_C` from 5.8843 to 8.7161,
+and the ratchet would have been the thing that was wrong.
+
+So "not comparable" is a third outcome, and it is not a pass.
+"""
+
+from __future__ import annotations
+
+from maintainability_audit._ratchet import TOLERANCE, dimension_ratchet
+from maintainability_audit._scan_history import ScanRecord
+
+
+def _record(
+    commit: str,
+    categories: dict[str, float],
+    *,
+    calibration: float = 8.7161,
+    aspects: dict[str, float] | None = None,
+) -> ScanRecord:
+    return ScanRecord(
+        recorded_at=f"2026-09-0{commit[-1]}T00:00:00Z",
+        commit=commit,
+        branch="main",
+        scope="repository",
+        rubric_version="2",
+        calibration=calibration,
+        thresholds_digest="same",
+        analyzers=("lizard", "jscpd"),
+        scored_languages=("python",),
+        estimate=4.0,
+        categories=categories,
+        aspects=aspects or {},
+    )
+
+
+def test_a_dimension_that_slipped_is_named() -> None:
+    """The failure the ratchet exists for: one up, one down, both green."""
+    records = [
+        _record("aaaaaa1", {"modularity": 4.0, "testability": 4.2}),
+        _record("aaaaaa2", {"modularity": 4.4, "testability": 3.6}),
+    ]
+
+    result = dimension_ratchet(records)
+
+    assert result["comparable"] is True
+    assert result["held"] is False
+    assert [item["name"] for item in result["regressed"]] == ["testability"]
+    assert result["regressed"][0]["drop"] == 0.6
+    assert result["regressed"][0]["was"] == 4.2
+
+
+def test_an_improvement_is_not_a_regression() -> None:
+    records = [
+        _record("aaaaaa1", {"modularity": 4.0}),
+        _record("aaaaaa2", {"modularity": 4.5}),
+    ]
+
+    assert dimension_ratchet(records)["held"] is True
+
+
+def test_movement_inside_the_rounding_boundary_is_not_a_slide() -> None:
+    """Scores are reported to one decimal; noise below that is not news."""
+    records = [
+        _record("aaaaaa1", {"modularity": 4.00}),
+        _record("aaaaaa2", {"modularity": 4.00 - TOLERANCE / 2}),
+    ]
+
+    assert dimension_ratchet(records)["held"] is True
+
+
+def test_scans_across_an_instrument_change_are_not_comparable() -> None:
+    """The case that would have made this ratchet a liability.
+
+    2.0.0 moved `CALIBRATION_C` 5.8843 -> 8.7161. Every score moved with it,
+    and subtracting across that boundary would report a catastrophic
+    regression everywhere while nothing about the code had changed.
+    """
+    records = [
+        _record("aaaaaa1", {"modularity": 4.6}, calibration=5.8843),
+        _record("aaaaaa2", {"modularity": 3.1}, calibration=8.7161),
+    ]
+
+    result = dimension_ratchet(records)
+
+    assert result["comparable"] is False, (
+        "scores from two different calibrations were subtracted"
+    )
+    assert result["regressed"] == []
+    assert "instrument" in result["reason"] or "different" in result["reason"]
+
+
+def test_not_comparable_is_not_a_pass() -> None:
+    """A caller must be able to tell "nothing regressed" from "nobody asked".
+
+    Both have an empty `regressed` list, so the distinction has to live
+    somewhere a gate can read, and `held` must not be true where the
+    question was never asked.
+    """
+    single = dimension_ratchet([_record("aaaaaa1", {"modularity": 4.0})])
+
+    assert single["comparable"] is False
+    assert single["regressed"] == []
+    assert single.get("held") is not True, (
+        "a scan with nothing to compare against reported that it held"
+    )
+
+
+def test_an_aspect_that_became_unmeasurable_is_not_a_drop() -> None:
+    """Withheld evidence must never read as a failure.
+
+    P3: withholding evidence cannot improve the grade — and the inversion
+    matters just as much. An aspect that stops being measurable is reported
+    as Unknown by the evidence model, not as a zero, so scoring its absence
+    as a fall to nothing would turn missing evidence into a regression.
+    """
+    records = [
+        _record("aaaaaa1", {"modularity": 4.0}, aspects={"documentation": 4.5}),
+        _record("aaaaaa2", {"modularity": 4.0}, aspects={}),
+    ]
+
+    result = dimension_ratchet(records)
+
+    assert result["aspects"] == []
+    assert result["held"] is True
+
+
+def test_aspects_are_reported_but_do_not_decide_the_verdict() -> None:
+    """An aspect can wobble while its category holds.
+
+    Failing on every aspect movement makes the gate noise, and a noisy gate
+    gets switched off — but hiding what moved underneath makes the verdict
+    unactionable, so aspects are reported beside the decision.
+    """
+    records = [
+        _record("aaaaaa1", {"modularity": 4.0}, aspects={"file_size": 4.4}),
+        _record("aaaaaa2", {"modularity": 4.0}, aspects={"file_size": 3.2}),
+    ]
+
+    result = dimension_ratchet(records)
+
+    assert [item["name"] for item in result["aspects"]] == ["file_size"]
+    assert result["regressed"] == []
+    assert result["held"] is True

{maintainability_agent-2.1.0 → maintainability_agent-2.2.0}/tests/test_identity_resolution.py

@@ -288,7 +288,11 @@ def test_fail_on_new_uses_structured_matching_not_a_label_set_difference() -> No
                 offenders.append(f"{path.name}:{node.lineno}")
     assert not offenders, f"label-set finding comparison remains at {offenders}"
 
-    cli_tree = ast.parse((package / "cli.py").read_text(encoding="utf-8"))
+    # `audit_exit_code` moved to `_gates` in 2.2.0, when `cli.py` crossed
+    # the 500-line file gate. The guard follows the function rather than the
+    # filename: what it pins is that the gate matches findings structurally,
+    # wherever that gate lives.
+    cli_tree = ast.parse((package / "_gates.py").read_text(encoding="utf-8"))
     audit_exit = next(
         node for node in cli_tree.body
         if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))

{maintainability_agent-2.1.0 → maintainability_agent-2.2.0}/tests/test_scope_conformance.py

@@ -220,10 +220,11 @@ def test_the_gate_reads_clean_not_conformant(tmp_path: Path) -> None:
     `audit_exit_code`, because the decision this test is about lives in the
     gate and not in the record.
     """
-    from maintainability_audit.cli import audit_exit_code
+    from maintainability_audit._gates import audit_exit_code
 
     args = SimpleNamespace(
         fail_on_new=False, fail_on_gate=False, fail_on_out_of_scope=True,
+        fail_on_regression=False,
         baseline=None, conformance="main...HEAD",
     )
     silenced = {"hard_gate_failures": [], "scope_conformance": {
@@ -244,10 +245,11 @@ def test_asking_to_fail_without_asking_to_check_is_refused() -> None:
     which is the "absence read as a pass" shape this project treats as a
     defect class rather than an inconvenience.
     """
-    from maintainability_audit.cli import audit_exit_code
+    from maintainability_audit._gates import audit_exit_code
 
     args = SimpleNamespace(
         fail_on_new=False, fail_on_gate=False, fail_on_out_of_scope=True,
+        fail_on_regression=False,
         baseline=None, conformance=None,
     )
 
@@ -255,7 +257,7 @@ def test_asking_to_fail_without_asking_to_check_is_refused() -> None:
 
 
 def test_attach_conformance_does_nothing_unless_asked() -> None:
-    from maintainability_audit.cli import attach_conformance
+    from maintainability_audit._gates import attach_conformance
 
     report = {"root": ".", "work_order": []}
     attach_conformance(SimpleNamespace(conformance=None), report)
@@ -273,7 +275,7 @@ def test_attach_conformance_records_against_a_real_diff(tmp_path: Path) -> None:
     """
     import subprocess
 
-    from maintainability_audit.cli import attach_conformance
+    from maintainability_audit._gates import attach_conformance
 
     def run(*args: str) -> None:
         subprocess.run(args, cwd=tmp_path, check=True, capture_output=True, timeout=120)  # noqa: S603