maintainability-agent 4.2.0__tar.gz → 4.3.0__tar.gz

{maintainability_agent-4.2.0/src/maintainability_agent.egg-info → maintainability_agent-4.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maintainability-agent
-Version: 4.2.0
+Version: 4.3.0
 Summary: Maintainability gate and AI remediation prompt generator for CI.
 Author: Marshall Guillory
 License: MIT
@@ -47,7 +47,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 **4.2.0**.
+Version **4.3.0**.
 
 > ## **Calibrated against 201 mature open-source repositories in fifteen languages.**
 >
@@ -509,7 +509,7 @@ instead of an invokable skill:
 This repo ships `action.yml`, usable as a composite action:
 
 ```yaml
-- uses: marshallguillory86/maintainability-agent@v4.2.0
+- uses: marshallguillory86/maintainability-agent@v4.3.0
   with:
     config: maintainability-agent.json
     changed-only: main...HEAD

{maintainability_agent-4.2.0 → maintainability_agent-4.3.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 **4.2.0**.
+Version **4.3.0**.
 
 > ## **Calibrated against 201 mature open-source repositories in fifteen languages.**
 >
@@ -467,7 +467,7 @@ instead of an invokable skill:
 This repo ships `action.yml`, usable as a composite action:
 
 ```yaml
-- uses: marshallguillory86/maintainability-agent@v4.2.0
+- uses: marshallguillory86/maintainability-agent@v4.3.0
   with:
     config: maintainability-agent.json
     changed-only: main...HEAD

{maintainability_agent-4.2.0 → maintainability_agent-4.3.0/src/maintainability_agent.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maintainability-agent
-Version: 4.2.0
+Version: 4.3.0
 Summary: Maintainability gate and AI remediation prompt generator for CI.
 Author: Marshall Guillory
 License: MIT
@@ -47,7 +47,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 **4.2.0**.
+Version **4.3.0**.
 
 > ## **Calibrated against 201 mature open-source repositories in fifteen languages.**
 >
@@ -509,7 +509,7 @@ instead of an invokable skill:
 This repo ships `action.yml`, usable as a composite action:
 
 ```yaml
-- uses: marshallguillory86/maintainability-agent@v4.2.0
+- uses: marshallguillory86/maintainability-agent@v4.3.0
   with:
     config: maintainability-agent.json
     changed-only: main...HEAD

{maintainability_agent-4.2.0 → maintainability_agent-4.3.0}/src/maintainability_agent.egg-info/SOURCES.txt

@@ -22,6 +22,7 @@ src/maintainability_audit/_banner.py
 src/maintainability_audit/_built_ins.py
 src/maintainability_audit/_calibration.py
 src/maintainability_audit/_catalog.py
+src/maintainability_audit/_changed_code_policy.py
 src/maintainability_audit/_charts.py
 src/maintainability_audit/_cognitive.py
 src/maintainability_audit/_config_defaults.py
@@ -179,6 +180,8 @@ tests/test_analyzer_provenance_exclusions.py
 tests/test_analyzer_scoring_path.py
 tests/test_analyzer_spread_range.py
 tests/test_analyzer_xml_bounds.py
+tests/test_analyzers_against_the_real_tools.py
+tests/test_analyzers_report_what_actually_failed.py
 tests/test_anchor_and_mode.py
 tests/test_anchor_caveat_and_counts_follow_the_run.py
 tests/test_anchor_disclosure.py
@@ -208,6 +211,7 @@ tests/test_calibration_drift.py
 tests/test_calibration_tooling.py
 tests/test_catalog_selection.py
 tests/test_catalog_tier_promise.py
+tests/test_changed_code_policy.py
 tests/test_chat_leads_with_the_work_order.py
 tests/test_chat_primary_docs.py
 tests/test_check_refuses_plus_only_fragments.py

{maintainability_agent-4.2.0 → maintainability_agent-4.3.0}/src/maintainability_audit/__init__.py

@@ -1,3 +1,3 @@
 """Maintainability Audit CI."""
 
-__version__ = "4.2.0"
+__version__ = "4.3.0"

{maintainability_agent-4.2.0 → maintainability_agent-4.3.0}/src/maintainability_audit/_adapters.py

@@ -118,6 +118,36 @@ def _format_default(_base: Path, tree: str) -> tuple[str, ...]:
     return (tree, f"{tree}/**")
 
 
+_REGEX_DIALECTS = frozenset({"regex", "rel_regex"})
+
+
+def _name_as_regex(pattern: str) -> str:
+    """A shell-style name as a regex that finds it as a path component anywhere.
+
+    `*` and `?` stay inside one component, as they do for the built-in
+    scan's own matcher; the name matches at the start of the path or after
+    a `/`, and ends at a `/` or the end, so `.venv/` is not `venv_tools.py`.
+    Works for `re.match` on an absolute path (pylint) and `re.search` on a
+    relative one (mypy) alike.
+    """
+    body = "".join("[^/]*" if ch == "*" else "[^/]" if ch == "?" else re.escape(ch)
+                   for ch in pattern.strip("/"))
+    return f"(?:^|.*/){body}(?:/|$)"
+
+
+def _names_as_paths(excludes: Sequence[str], root: Path) -> tuple[str, ...]:
+    """Plain path names as absolute paths under the root; wildcards dropped.
+
+    A path dialect (interrogate's `--exclude`) names locations, so
+    `calibration/.corpus/` becomes `<root>/calibration/.corpus`. A wildcard
+    such as `*.min.js` names no location and cannot be spelled here; it is
+    left out, which can only under-exclude — the scan's own filter still
+    applies it to what the tool reports.
+    """
+    return tuple(str(root / pattern.strip("/")) for pattern in excludes
+                 if not any(ch in pattern for ch in "*?["))
+
+
 _TREE_FORMATTERS = {
     "fnmatch": _format_fnmatch,
     "regex": _format_regex,
@@ -267,7 +297,7 @@ class BaseAdapter:
         """
         if not self.exclude_flag:
             return ()
-        entries = tuple(excludes) + self.tree_patterns(
+        entries = self.operator_patterns(excludes, root) + self.tree_patterns(
             getattr(excludes, "trees", ()), root
         )
         if not entries:
@@ -279,6 +309,21 @@ class BaseAdapter:
             return tuple(repeated)
         return (self.exclude_flag, self.exclude_separator.join(entries))
 
+    def operator_patterns(self, excludes: Sequence[str], root: Path | None = None) -> tuple[str, ...]:
+        """The operator's exclude names, spelled for this tool's matcher.
+
+        They are shell-style names — `.venv/`, `*.egg-info/` — and for most
+        dialects they pass through as written. A regex dialect compiles
+        them: pylint's `--ignore-paths` refused `*.egg-info` ("nothing to
+        repeat"), exited with an argument error, and analysed nothing, on
+        every repository whose config carried a glob (the default does).
+        """
+        if self.exclude_dialect == "abspath":
+            return _names_as_paths(excludes, Path(root) if root is not None else Path("."))
+        if self.exclude_dialect not in _REGEX_DIALECTS:
+            return tuple(excludes)
+        return tuple(_name_as_regex(pattern) for pattern in excludes)
+
     def tree_patterns(
         self, trees: Sequence[str], root: Path | None = None
     ) -> tuple[str, ...]:

{maintainability_agent-4.2.0 → maintainability_agent-4.3.0}/src/maintainability_audit/_analysis.py

@@ -447,6 +447,7 @@ def _attempt(root: Path, adapter: Any, probe: Probe, timeout: int,
         )
 
     result, parsed = _run_batches(adapter, root, excludes, timeout)
+    result = _silent_failure(adapter.slug, result, parsed)
     # Filtered before the counts are taken, not after. Recording 48
     # measurements and reporting 6 describes an activity rather than a
     # result, which is the defect this project keeps finding.
@@ -500,6 +501,24 @@ def _run_batches(adapter: Any, root: Path, excludes: Sequence[str],
     return _merged_result(results, len(invocations)), _merged_extraction(parsed)
 
 
+def _silent_failure(slug: str, result: ToolResult, parsed: Extraction) -> ToolResult:
+    """A tool that wrote nothing failed, whatever its exit code says.
+
+    pylint's argument error exits 2, which is also its "error messages
+    issued" bit, so a run that analysed nothing counted as one that worked
+    and its empty output was reported as unreadable JSON while stderr held
+    the reason. secure-code-agent recorded the same class as its D30: let
+    the output decide, and let the failure carry what the tool said.
+    """
+    if not (parsed.parse_error and result.usable and not (result.stdout or "").strip()):
+        return result
+    said = " ".join((result.stderr or "").split())[:400]
+    if not said:
+        return result
+    return replace(result, outcome=Outcome.FAILED,
+                   detail=f"{slug} exited {result.exit_code} and wrote no output; it said: {said}")
+
+
 def _merged_result(results: list[ToolResult], planned: int) -> ToolResult:
     failed = next((r for r in results if not r.usable), None)
     basis = failed or results[0]

maintainability_agent-4.3.0/src/maintainability_audit/_changed_code_policy.py

@@ -0,0 +1,98 @@
+"""Code a change touches is held to a stricter bar (Decision 15).
+
+A repository adopting a quality gate cannot fix every old long function
+first, and a gate that fails on all of them is a gate nobody turns on.
+`policy.changed_code` sets stricter function limits, and on a run against a
+change only the functions that change touched are held to them; untouched
+code is judged by the standard as before.
+
+A function is *touched* when the change added or altered a line inside it —
+`git diff --unified=0` lines, so context does not count and a pure deletion
+touches nothing. Classes are not held to it: their budget is a container's,
+and their methods are functions in their own right.
+
+Two rules from the decision, enforced here rather than trusted:
+
+- **A policy only tightens.** A limit looser than the standard threshold is
+  refused when the configuration loads, by name, as `PolicyError` — the
+  refusal both doors already turn into a message.
+- **It never moves the grade.** Its result is `report["policy"]`, beside the
+  score rather than inside `hard_gate_failures`, which the scorer reads.
+  `--fail-on-gate` reads both.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ._catalog import PolicyError
+
+#: Each policy key: the standard threshold it may only tighten, the
+#: function-metric field it reads, and the name a failure reports.
+LIMITS: dict[str, tuple[str, str, str]] = {
+    "max_function_lines": ("max_function_lines", "lines", "function_lines"),
+    "max_complexity": ("max_complexity", "complexity", "complexity"),
+    "max_cognitive_complexity": ("max_cognitive_complexity", "cognitive", "cognitive_complexity"),
+}
+
+
+def changed_code_limits(config: dict[str, Any]) -> dict[str, int]:
+    """The configured limits, or empty when the repository sets none."""
+    return dict((config.get("policy") or {}).get("changed_code") or {})
+
+
+def validate(config: dict[str, Any]) -> None:
+    """Refuse a limit that is unknown, not a positive integer, or looser than the standard."""
+    thresholds = config.get("thresholds") or {}
+    for key, value in changed_code_limits(config).items():
+        if key not in LIMITS:
+            raise PolicyError(
+                f"unknown policy.changed_code key {key!r}; expected one of {sorted(LIMITS)}")
+        if isinstance(value, bool) or not isinstance(value, int) or value < 1:
+            raise PolicyError(f"policy.changed_code.{key} must be a positive integer, not {value!r}")
+        standard = thresholds.get(LIMITS[key][0])
+        if isinstance(standard, int) and value > standard:
+            raise PolicyError(
+                f"policy.changed_code.{key} is {value}, looser than the standard "
+                f"thresholds.{LIMITS[key][0]} of {standard}; a policy may only tighten")
+
+
+def evaluate(function_metrics: list[Any], touched_lines: dict[str, set[int]],
+             config: dict[str, Any], revspec: str) -> dict[str, Any] | None:
+    """Every touched function's breaches of the policy, or None without a policy."""
+    limits = changed_code_limits(config)
+    if not limits:
+        return None
+    touched = [metric for metric in function_metrics if _touched(metric, touched_lines)]
+    return {
+        "revspec": revspec,
+        "limits": limits,
+        "touched_functions": len(touched),
+        "failures": [failure for metric in touched for failure in _breaches(metric, limits)],
+    }
+
+
+def failures(report: dict[str, Any]) -> list[dict[str, Any]]:
+    """The policy's failures in a finished report; empty when no policy ran."""
+    return list((report.get("policy") or {}).get("failures") or [])
+
+
+def _touched(metric: Any, touched_lines: dict[str, set[int]]) -> bool:
+    if getattr(metric, "kind", "function") == "class":
+        return False
+    lines = touched_lines.get(metric.path)
+    if not lines:
+        return False
+    end = metric.start_line + metric.lines
+    return any(metric.start_line <= line < end for line in lines)
+
+
+def _breaches(metric: Any, limits: dict[str, int]) -> list[dict[str, Any]]:
+    found = []
+    for key, limit in limits.items():
+        _standard, field, measure = LIMITS[key]
+        value = getattr(metric, field, None)
+        if isinstance(value, int) and value > limit:
+            found.append({"path": metric.path, "name": metric.name, "start_line": metric.start_line,
+                          "measure": measure, "value": value, "limit": limit})
+    return found

{maintainability_agent-4.2.0 → maintainability_agent-4.3.0}/src/maintainability_audit/_gates.py

@@ -18,6 +18,7 @@ import argparse
 import sys
 from pathlib import Path
 
+from ._changed_code_policy import failures as policy_failures
 from .baseline import findings_not_in_baseline
 from .git_tools import added_lines, changed_paths, removed_lines
 
@@ -147,7 +148,7 @@ def audit_exit_code(args: argparse.Namespace, report: dict) -> int:
         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"]:
+    if args.fail_on_gate and (report["hard_gate_failures"] or policy_failures(report)):
         return 1
     conformance = _conformance_exit(args, report)
     if conformance:

{maintainability_agent-4.2.0 → maintainability_agent-4.3.0}/src/maintainability_audit/_html_view.py

@@ -318,15 +318,36 @@ def _work_order_section(report: dict[str, Any]) -> list[str]:
 
 def _hard_gate_section(report: dict[str, Any]) -> list[str]:
     failures = report.get("hard_gate_failures") or []
+    rows: list[str] = []
+    if failures:
+        rows = [
+            "<h2>Hard gates</h2>",
+            "<table><tr><th>Severity</th><th>Gate</th></tr>",
+        ]
+        rows.extend(
+            f"<tr><td class='sev-Severe'>Severe</td><td>{escape(str(gate))}</td></tr>"
+            for gate in failures
+        )
+        rows.append("</table>")
+    return rows + _policy_section(report)
+
+
+def _policy_section(report: dict[str, Any]) -> list[str]:
+    """The changed-code policy beside the gates, as the markdown prints it (Decision 15)."""
+    policy = report.get("policy")
+    failures = (policy or {}).get("failures") or []
     if not failures:
         return []
     rows = [
-        "<h2>Hard gates</h2>",
-        "<table><tr><th>Severity</th><th>Gate</th></tr>",
+        "<h2>Changed-code policy</h2>",
+        f"<p class='muted'>Functions touched by {escape(str(policy.get('revspec')))} are held to "
+        "this repository's stricter limits. The grade is unaffected.</p>",
+        "<table><tr><th>Location</th><th>Function</th><th>Measure</th><th>Value</th><th>Limit</th></tr>",
     ]
     rows.extend(
-        f"<tr><td class='sev-Severe'>Severe</td><td>{escape(str(gate))}</td></tr>"
-        for gate in failures
+        f"<tr><td>{escape(str(f['path']))}:{f['start_line']}</td><td>{escape(str(f['name']))}</td>"
+        f"<td>{escape(str(f['measure']))}</td><td>{f['value']}</td><td>{f['limit']}</td></tr>"
+        for f in failures
     )
     rows.append("</table>")
     return rows

{maintainability_agent-4.2.0 → maintainability_agent-4.3.0}/src/maintainability_audit/_mcp_audit.py

@@ -21,6 +21,7 @@ from typing import Any
 
 from ._calibration import CALIBRATION_C
 from ._catalog import PRESENTATIONS
+from ._changed_code_policy import failures as policy_failures
 from ._grant_ledger import (
     ALLOWED_ROOTS_ENV as ALLOWED_ROOTS_ENV,  # noqa: PLC0414 - re-export
 )
@@ -396,7 +397,8 @@ def _top_level_result(report: dict[str, Any], root: Path, status: str,
         "audit_ran": True,
         "source_commit": probe_git(["rev-parse", "HEAD"], root) or None,
         "worktree_dirty": bool(status),
-        "gate_passed": not report["hard_gate_failures"],
+        # The changed-code policy is a gate too (Decision 15); the CLI reads both.
+        "gate_passed": not (report["hard_gate_failures"] or policy_failures(report)),
         # Stated at the top level so a caller cannot mistake an audit that
         # ran six built-in detectors for one that ran ten tools. Two
         # reports with different coverage are not comparable (P8).

{maintainability_agent-4.2.0 → maintainability_agent-4.3.0}/src/maintainability_audit/_metric_adapters.py

@@ -321,10 +321,12 @@ class CohesionAdapter(BaseAdapter):
         super().__init__(
             slug="cohesion", emits="metric", executable="cohesion",
             concepts=("cohesion",), exclude_dialect="files",
-            # Its CLI takes files or a directory and has no version flag,
-            # so availability is answered from package metadata, the same
-            # arrangement multimetric already uses.
-            distribution="cohesion",
+            # Its CLI takes files or a directory and has no version flag, so
+            # the version comes from package metadata — and availability
+            # from `--help`, the arrangement multimetric uses. The probe was
+            # `--version`, which argparse rejects with exit 2, so cohesion
+            # was recorded as failed without ever being asked to run.
+            version_flag="--help", distribution="cohesion",
         )
 
     def has_targets(self, root: Path, excludes: Sequence[str] = ()) -> bool:

{maintainability_agent-4.2.0 → maintainability_agent-4.3.0}/src/maintainability_audit/_ratio_adapters.py

@@ -134,7 +134,10 @@ class InterrogateAdapter(BaseAdapter):
         super().__init__(
             slug="interrogate", emits="metric", executable="interrogate",
             concepts=("documentation",), findings_exit_codes=(0, 1),
-            exclude_flag="--exclude", exclude_separator=" ",
+            # One `--exclude` per path: interrogate names one location per
+            # flag, and a space-joined list named none, so excluded trees
+            # were analysed and one unparseable file in them crashed it.
+            exclude_flag="--exclude", exclude_repeat=True,
             exclude_dialect="abspath",
         )
 

{maintainability_agent-4.2.0 → maintainability_agent-4.3.0}/src/maintainability_audit/config.py

@@ -7,6 +7,7 @@ from typing import Any
 # Re-exported: the defaults live in `_config_defaults`, this module is
 # still the door every caller comes through.
 from . import __version__ as _package_version
+from ._changed_code_policy import validate as validate_changed_code_policy
 from ._config_defaults import DEFAULT_CONFIG, DEFAULT_IDIOM_GROUPS
 from ._operator_reads import (
     MAX_OPERATOR_FILE_BYTES as MAX_OPERATOR_FILE_BYTES,
@@ -164,6 +165,7 @@ def load_config(path: str | None) -> dict[str, Any]:
         _merge_tier(config, user_tier)
     if path:
         _merge_tier(config, _host_authority_stripped(_configured(Path(path))))
+    validate_changed_code_policy(config)
     return config
 
 

{maintainability_agent-4.2.0 → maintainability_agent-4.3.0}/src/maintainability_audit/renderers.py

@@ -178,11 +178,32 @@ def render_markdown(report: dict[str, Any], *, complete: bool = True) -> str:
 
 
 def _hard_gate_lines(report: dict[str, Any]) -> list[str]:
-    """The hard-gate list, printed the same way wherever it appears."""
-    if not report["hard_gate_failures"]:
+    """The hard-gate list, printed the same way wherever it appears.
+
+    The changed-code policy follows it: also a gate, never a grade
+    (Decision 15), so it is printed wherever the gates are.
+    """
+    lines: list[str] = []
+    if report["hard_gate_failures"]:
+        lines += ["## Hard Gate Failures", "",
+                  *(f"- {gate}" for gate in report["hard_gate_failures"]), ""]
+    return lines + _policy_lines(report)
+
+
+def _policy_lines(report: dict[str, Any]) -> list[str]:
+    policy = report.get("policy")
+    if not policy:
         return []
-    return ["## Hard Gate Failures", "",
-            *(f"- {gate}" for gate in report["hard_gate_failures"]), ""]
+    failures = policy.get("failures") or []
+    head = (f"{policy.get('touched_functions', 0)} function(s) touched by "
+            f"`{policy.get('revspec')}` are held to this repository's stricter limits; "
+            "the grade is unaffected.")
+    if not failures:
+        return ["## Changed-code policy", "", head + " All of them meet it.", ""]
+    rows = [f"| `{f['path']}:{f['start_line']}` | `{f['name']}` | {f['measure']} | {f['value']} | {f['limit']} |"
+            for f in failures]
+    return ["## Changed-code policy", "", head, "",
+            "| Location | Function | Measure | Value | Limit |", "|---|---|---|---|---|", *rows, ""]
 
 
 def _no_work_order_lines() -> list[str]:

{maintainability_agent-4.2.0 → maintainability_agent-4.3.0}/src/maintainability_audit/report.py

@@ -16,6 +16,8 @@ from typing import Any
 
 from ._analyzer_sections import analyzer_sections
 from ._built_ins import record_built_in_counts
+from ._changed_code_policy import changed_code_limits
+from ._changed_code_policy import evaluate as evaluate_changed_code_policy
 from ._delegated_pillar import read_delegated
 from ._discovery import Provenance, discover
 from ._economics import economic_context_from, economic_impact, reorder_by_exposure
@@ -36,7 +38,7 @@ from .deadcode import dead_declarations
 from .declarations import DECLARATION_SUFFIXES
 from .duplication import duplicate_blocks, risk_findings
 from .evidence import REPORT_SCHEMA_VERSION, SCHEMA_VERSION_KEY
-from .git_tools import probe_git, worktree_status
+from .git_tools import added_lines, probe_git, worktree_status
 from .history import history_section
 from .idioms import divergent_idioms
 from .metrics import (
@@ -463,6 +465,32 @@ def _pillars_with_delegation(
     return pillars
 
 
+def _attach_economics(report: dict[str, Any], config: dict[str, Any]) -> None:
+    """ADR 004 v1, after scoring on purpose.
+
+    Nothing money-shaped exists until the score document is final, so no
+    path from these numbers into the estimate or the grade can exist to be
+    misused.
+    """
+    context = economic_context_from(config)
+    if context is not None:
+        report["economic_impact"] = economic_impact(report, context)
+        reorder_by_exposure(report)
+
+
+def _attach_policy(report: dict[str, Any], root: Path, config: dict[str, Any],
+                   function_metrics: list[FunctionMetric], changed_revspec: str | None) -> None:
+    """The changed-code policy, beside the score and never inside it (Decision 15).
+
+    Only a repository that set a policy pays for the diff; without one
+    nothing new runs.
+    """
+    if not (changed_revspec and changed_code_limits(config)):
+        return
+    touched = {path: {n for n, _ in rows} for path, rows in added_lines(root, changed_revspec).items()}
+    report["policy"] = evaluate_changed_code_policy(function_metrics, touched, config, changed_revspec)
+
+
 def build_report(
     root: Path,
     config: dict[str, Any],
@@ -528,6 +556,7 @@ def build_report(
     report["tdd_structure"] = describe_tdd(root, file_metrics, function_metrics, source)
     _attach_test_suite(report, root, config)
     report["score"] = score_report(report, analyzer["pressures"])
+    _attach_policy(report, root, config, function_metrics, changed_revspec)
     # Condition rolls up aspects; practice stays a separate axis (ADR 007).
     report["practice"] = practice_level(root, config).as_dict()
     report["pillars"] = _pillars_with_delegation(report, root, security_pillar, changed_revspec, config)
@@ -535,11 +564,5 @@ def build_report(
     # Last, because every item's delta is a rubric recomputation and the
     # rubric needs the scored report to recompute against.
     report["work_order"] = work_order(report, thresholds=config["thresholds"])
-    # ADR 004 v1, after scoring on purpose: nothing money-shaped exists
-    # until the score document is final, so no path from these numbers
-    # into the estimate or the grade can exist to be misused.
-    context = economic_context_from(config)
-    if context is not None:
-        report["economic_impact"] = economic_impact(report, context)
-        reorder_by_exposure(report)
+    _attach_economics(report, config)
     return report

maintainability_agent-4.3.0/tests/test_analyzers_against_the_real_tools.py

@@ -0,0 +1,42 @@
+"""D226's fixes, against the installed tools.
+
+Covers existing behaviour: these run the real interrogate and cohesion and
+skip where a tool is not installed, so in an environment without them they
+pass without proving anything. The falsifiers for the same changes are in
+`test_analyzers_report_what_actually_failed.py` and need no tool; these
+check that the fixes hold against the tools themselves.
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from maintainability_audit import _analysis
+from maintainability_audit._runner import Outcome
+from maintainability_audit._tool_adapters import ADAPTERS
+
+
+@pytest.mark.skipif(shutil.which("cohesion") is None, reason="cohesion is not installed here")
+def test_cohesions_availability_probe_is_a_flag_it_has() -> None:
+    probe = subprocess.run(list(ADAPTERS["cohesion"]().version_argv()), capture_output=True, text=True)
+
+    assert probe.returncode == 0, probe.stderr
+
+
+@pytest.mark.skipif(shutil.which("interrogate") is None, reason="interrogate is not installed here")
+def test_an_excluded_unparseable_file_no_longer_hides_the_percentage(tmp_path: Path) -> None:
+    (tmp_path / "app.py").write_text('"""Documented."""\n\n\ndef f():\n    """Yes."""\n', encoding="utf-8")
+    (tmp_path / "vendor_corpus").mkdir()
+    (tmp_path / "vendor_corpus" / "old.py").write_text('print "python 2"\n', encoding="utf-8")
+    probe = SimpleNamespace(check=lambda slug, argv: SimpleNamespace(
+        usable=True, version="interrogate", outcome=Outcome.RAN, detail=""))
+
+    coverage = _analysis._attempt(tmp_path, ADAPTERS["interrogate"](), probe, 60, _analysis.Analysis(),
+                                  ("vendor_corpus/",))
+
+    assert coverage.outcome == "ran" and coverage.measurements == 1, coverage.detail or coverage.parse_error