maintainability-agent 2.11.2__tar.gz → 3.0.0__tar.gz

{maintainability_agent-2.11.2/src/maintainability_agent.egg-info → maintainability_agent-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maintainability-agent
-Version: 2.11.2
+Version: 3.0.0
 Summary: Maintainability gate and AI remediation prompt generator for CI.
 Author: Marshall Guillory
 License: MIT
@@ -45,7 +45,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.11.2**.
+Version **3.0.0**.
 
 **Planned, not shipped:** the audit tool will become `maintainability-audit`;
 a new `maintainability-agent` companion will run it and automate human-selected
@@ -397,7 +397,9 @@ findings — is in the report itself.
 ## Platform support
 
 **POSIX. Windows is not claimed, for a measured reason.** A `windows-latest` probe
-found most failures in two POSIX-only calls, `os.fchmod` and `os.O_DIRECTORY`. The
+found most failures in three POSIX-only calls: `os.fchmod`, `os.O_DIRECTORY` and
+`os.O_NONBLOCK`. The third arrived with the one-handle operator read (D130/D131)
+and is now the dominant failure in the probe, which is why the count moved. The
 bounded, symlink-refusing write works through a *file descriptor*, so a validated
 path cannot be swapped for a symlink before the write lands — Windows has no
 equivalent and the portable rewrite is the hole. **An unsupported platform never

{maintainability_agent-2.11.2 → maintainability_agent-3.0.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.11.2**.
+Version **3.0.0**.
 
 **Planned, not shipped:** the audit tool will become `maintainability-audit`;
 a new `maintainability-agent` companion will run it and automate human-selected
@@ -357,7 +357,9 @@ findings — is in the report itself.
 ## Platform support
 
 **POSIX. Windows is not claimed, for a measured reason.** A `windows-latest` probe
-found most failures in two POSIX-only calls, `os.fchmod` and `os.O_DIRECTORY`. The
+found most failures in three POSIX-only calls: `os.fchmod`, `os.O_DIRECTORY` and
+`os.O_NONBLOCK`. The third arrived with the one-handle operator read (D130/D131)
+and is now the dominant failure in the probe, which is why the count moved. The
 bounded, symlink-refusing write works through a *file descriptor*, so a validated
 path cannot be swapped for a symlink before the write lands — Windows has no
 equivalent and the portable rewrite is the hole. **An unsupported platform never

{maintainability_agent-2.11.2 → maintainability_agent-3.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "maintainability-agent"
-version = "2.11.2"
+version = "3.0.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.11.2 → maintainability_agent-3.0.0/src/maintainability_agent.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maintainability-agent
-Version: 2.11.2
+Version: 3.0.0
 Summary: Maintainability gate and AI remediation prompt generator for CI.
 Author: Marshall Guillory
 License: MIT
@@ -45,7 +45,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.11.2**.
+Version **3.0.0**.
 
 **Planned, not shipped:** the audit tool will become `maintainability-audit`;
 a new `maintainability-agent` companion will run it and automate human-selected
@@ -397,7 +397,9 @@ findings — is in the report itself.
 ## Platform support
 
 **POSIX. Windows is not claimed, for a measured reason.** A `windows-latest` probe
-found most failures in two POSIX-only calls, `os.fchmod` and `os.O_DIRECTORY`. The
+found most failures in three POSIX-only calls: `os.fchmod`, `os.O_DIRECTORY` and
+`os.O_NONBLOCK`. The third arrived with the one-handle operator read (D130/D131)
+and is now the dominant failure in the probe, which is why the count moved. The
 bounded, symlink-refusing write works through a *file descriptor*, so a validated
 path cannot be swapped for a symlink before the write lands — Windows has no
 equivalent and the portable rewrite is the hole. **An unsupported platform never

{maintainability_agent-2.11.2 → maintainability_agent-3.0.0}/src/maintainability_agent.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ src/maintainability_audit/__init__.py
 src/maintainability_audit/__main__.py
 src/maintainability_audit/_adapters.py
 src/maintainability_audit/_analysis.py
+src/maintainability_audit/_analyzer_sections.py
 src/maintainability_audit/_anchor.py
 src/maintainability_audit/_arguments.py
 src/maintainability_audit/_aspects.py
@@ -27,6 +28,7 @@ src/maintainability_audit/_config_defaults.py
 src/maintainability_audit/_conformance.py
 src/maintainability_audit/_corroborate.py
 src/maintainability_audit/_coverage_notes.py
+src/maintainability_audit/_criteria_scope.py
 src/maintainability_audit/_derive.py
 src/maintainability_audit/_discovery.py
 src/maintainability_audit/_documents.py
@@ -199,10 +201,12 @@ tests/test_contract_claims.py
 tests/test_corroborate.py
 tests/test_coverage_by_language.py
 tests/test_cpp_declarations.py
+tests/test_criteria_completion.py
 tests/test_csharp_declarations.py
 tests/test_d15_composition.py
 tests/test_d15_goal_directed.py
 tests/test_dead_code.py
+tests/test_declaration_criteria_scope.py
 tests/test_declaration_edge_cases.py
 tests/test_declaration_grading.py
 tests/test_declaration_ranges.py
@@ -241,6 +245,7 @@ tests/test_git_read_only.py
 tests/test_git_readonly_class.py
 tests/test_go_declarations.py
 tests/test_grammar_constructs.py
+tests/test_grammar_token_coverage.py
 tests/test_grant_only_user_tier.py
 tests/test_history.py
 tests/test_history_boundary.py

{maintainability_agent-2.11.2 → maintainability_agent-3.0.0}/src/maintainability_audit/__init__.py

@@ -1,3 +1,3 @@
 """Maintainability Audit CI."""
 
-__version__ = "2.11.2"
+__version__ = "3.0.0"

maintainability_agent-3.0.0/src/maintainability_audit/_analyzer_sections.py

@@ -0,0 +1,85 @@
+"""The analyzer half of a report, and the join that completes it.
+
+Split from `report.py` at the 500-line gate this tool enforces on
+everyone else. The seam is real rather than arithmetic: everything here
+is about the external analyzer tier — what it measured, what it could
+not, and how its criterion set is completed from the built-in scanner so
+a language no tool reads cognitively can still be analyzer-driven.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from ._analysis import analyze
+from ._criteria_scope import built_in_readings
+from ._documents import (
+    coverage_document,
+    findings_document,
+    measurement_document,
+    unidentified_source_paths,
+)
+from ._environment import environment_work_order
+from ._metrics_types import FunctionMetric
+from ._pressures import (
+    ExternalPressures,
+    analyzer_pressures,
+    analyzer_production_pressures,
+    declined_dimensions,
+)
+
+
+def analyzer_sections(
+    root: Path,
+    config: dict[str, Any],
+    run_analyzers: bool,
+    function_metrics: list[FunctionMetric],
+) -> dict[str, Any]:
+    """The three analyzer sections, or their empty forms.
+
+    Extracted because `build_report` reached complexity 15 against this
+    project's own limit. Four conditionals all asking the same question
+    belong behind one, and the empty forms are stated here rather than
+    repeated at each call site.
+    """
+    if not run_analyzers:
+        return {"coverage": None, "findings": [], "measurements": {},
+                "pressures": None, "environment": []}
+    analysis = analyze(root, config)
+    coverage = coverage_document(analysis)
+    # P8: where the analyzer tier could not drive a dimension, say so on
+    # the coverage document rather than leaving the built-in fallback to
+    # be inferred from an absent number. Attached here because only this
+    # layer holds both the measurements and the rubric's thresholds.
+    # The scanner's own reading of each declaration, so the analyzer tier
+    # can complete a criterion set no single tool covers (per concept,
+    # not per dimension). Keyed the way the join is proven: (path, line).
+    prefix = root.as_posix().rstrip("/") + "/"
+    built_in = built_in_readings(function_metrics, prefix)
+    coverage["dimensions_declined"] = list(
+        declined_dimensions(analysis.measurements, False, built_in, prefix))
+    return {
+        "coverage": coverage,
+        # ADR 006 §2c: what did not run and what it would take, for the
+        # user to act on. Emitted here because only the analysis knows
+        # which tools were *selected*; the agent never runs the commands.
+        "environment": environment_work_order(analysis.coverage),
+        "findings": findings_document(analysis, root),
+        # Path spellings normalization refused (zero or several matches)
+        # — visible, so a refusal is never mistaken for an identification.
+        "unidentified_source_paths": unidentified_source_paths(analysis, root),
+        "measurements": measurement_document(analysis, root),
+        # The analyzers' reading of the scorer's dimensions, primary for
+        # each it covers (ADR 006 §1); where None the built-in stands, so
+        # an unmeasured dimension is unmeasured, not clean. Both
+        # populations, since the production aspects read this.
+        "pressures": ExternalPressures(
+            all_code=analyzer_pressures(
+                analysis.measurements, config["thresholds"], built_in, prefix),
+            production=analyzer_production_pressures(
+                analysis.measurements, config["thresholds"], built_in, prefix),
+            # The raw readings ride along so the scorer can price
+            # per-concept tool disagreement into the range (3.4).
+            measurements=tuple(analysis.measurements),
+        ),
+    }

{maintainability_agent-2.11.2 → maintainability_agent-3.0.0}/src/maintainability_audit/_calibration.py

@@ -107,11 +107,94 @@ CATEGORIES = ["modularity", "reusability", "analyzability", "modifiability", "te
 # the wrong unit of analysis; the languages do not behave as a bloc, and a
 # single dramatic repository predicted the direction of the whole corpus
 # incorrectly. Per-language readings are in `docs/calibration-2.0-study.md`.
+#
+# **2026-09-07, re-measured; the constants held.** The stored rows had been
+# measured at tool versions 1.10.1 and 2.0.0 under scanner fingerprint
+# 3b5e063e95316342. HEAD is 2.11.2 under 1a902618a0600746 — eleven minor
+# releases of scanner work later, including four new language scanners and
+# the D112-D136 fixes. All 112 repositories were re-measured
+# `--with-analyzers` at the same pinned commits, so every move below is
+# attributable to the scanners and to nothing else:
+#
+#     file_size      0.0952 -> 0.0952   unchanged
+#     declarations   0.0908 -> 0.0903   92 of 112 rows moved
+#     duplication    0.3222 -> 0.3222   unchanged
+#     risk           0.0826 -> 0.0811   21 rows moved
+#     gates          0.05   -> 0.05     fixed, not measured
+#     CALIBRATION_C  8.7161 -> 8.7161   re-bisected to the same value
+#
+# The constants are deliberately left as they stand. Both movers sit well
+# inside the 10% the suite tolerates (0.55% and 1.8%), and the curve
+# re-fitted to four identical decimals, so editing them would change the
+# published numbers by less than the sampling error in the numbers
+# themselves - the argument `test_the_curve_constant_still_does_its_job`
+# already makes for c.
+#
+# **No repository changes grade.** Old corpus and new, under the shipped
+# constants and under the re-derived ones, all give A=5, B=52, C=55 with a
+# median of exactly 4.0000. Two repositories move at the published decimal
+# at all: hoppscotch 3.6 -> 3.7 and googletest 4.1 -> 4.0.
+#
+# This is worth recording because the roadmap predicted the opposite - that
+# the recalibration "re-grades every repository, which is a breaking change
+# to every published number". For *scanner* drift that is now measured, and
+# it is false: 92 of 112 declaration readings moved underneath an anchor
+# that did not. It says nothing about extending the corpus to hold the six
+# unanchored languages, which moves the population the medians are drawn
+# from rather than the instrument reading it. That half remains untested.
+#
+# **2026-09-08, the recalibration (3.0.0).** The one this corpus policy
+# scheduled, and the first that re-grades repositories. Three things
+# changed at once and the release exists because they cannot be
+# separated — each moves `scanner_fingerprint` and invalidates every
+# stored row.
+#
+# *The corpus grew to 180.* Swift, Go, Rust, PHP and Ruby are anchored,
+# fourteen repositories each but for Ruby's twelve. COBOL is not, and
+# will not be: one public repository clears 500 stars and what exists is
+# curriculum, Java parsers and JavaScript wrappers rather than COBOL
+# codebases. The 112 existing rows keep their pinned commits.
+#
+# *The analyzer tier now drives declarations almost everywhere.* Under
+# 2.11.2 the criterion set could only be completed for Python, so 6 rows
+# of 180 carried an analyzer reading. Completing it from the built-in
+# tier per concept — `lizard` for cyclomatic complexity and declaration
+# lines, the scanner for the cognitive complexity no FOSS tool supplies
+# — takes that to **173 of 180**.
+#
+# *D137 fixed the criterion check's scope*, so one Python file can no
+# longer buy the criterion for a repository's C.
+#
+#     file_size      0.0952 -> 0.0938
+#     declarations   0.0908 -> 0.0962
+#     duplication    0.3222 -> 0.3144
+#     risk           0.0826 -> 0.0341
+#     gates          0.05   -> 0.05
+#     CALIBRATION_C  8.7161 -> 4.2565
+#
+# **`risk` more than halved, and the languages explain it.** Risk
+# patterns are configured policy and this project's defaults were written
+# against Python and C. Measured as a multiple of the new reference, the
+# five added languages read swift 0.00x, php 0.01x, ruby 0.04x, go 0.10x
+# and rust 0.26x, against c 5.82x, cpp 4.95x and python 4.24x. The median
+# fell because the corpus stopped being dominated by the two ecosystems
+# the default patterns were written for. That is the anchor working: the
+# old reference was measuring the pattern set, not the code.
+#
+# **This release re-grades repositories, which the previous one did not.**
+# 33 of the 112 repositories in both corpora change grade — 15 B->C,
+# 7 C->B, 5 A->B, 4 C->D and 2 B->A — and the corpus gains its first D
+# grades. The 2026-09-07 re-measure moved nothing and said so; this one
+# moves a third of them. Both statements are measured, which is why only
+# this one is a major version.
+#
+# The median still rolls up to exactly 4.0000, which is the anchor's
+# whole job and the one thing that must not move.
 DIMENSION_REFERENCES: dict[str, float] = {
-    "file_size": 0.0952,
-    "declarations": 0.0908,
-    "duplication": 0.3222,
-    "risk": 0.0826,
+    "file_size": 0.0938,
+    "declarations": 0.0962,
+    "duplication": 0.3144,
+    "risk": 0.0341,
     # Fixed, not corpus-derived — see ``_derive.FIXED_REFERENCES``, which
     # is the authority for this value and carries the reasoning. Stated
     # again here rather than imported, so the two are independent claims
@@ -175,7 +258,8 @@ DIMENSION_WEIGHTS: dict[str, float] = {
 # 2026-08-14: 2.6279 -> 2.2658, fitted against the analyzer-primary mix.
 # 2026-08-31: 2.2658 -> 5.8843, re-fitted after the corpus re-measure above
 # (three of five references moved at once, `duplication` most of all).
-CALIBRATION_C = 8.7161
+# 2026-09-08: 8.7161 -> 4.2565, the 3.0.0 recalibration above.
+CALIBRATION_C = 4.2565
 
 # A failure is a threshold breach; a warning is an approach to one.
 WARN_WEIGHT = 0.3

maintainability_agent-3.0.0/src/maintainability_audit/_criteria_scope.py

@@ -0,0 +1,279 @@
+"""Which declarations the analyzer tier may score — the D137 seam.
+
+Split out of `_pressures.py` when that module crossed the 500-line gate
+this tool enforces on everyone else. The seam is real rather than
+arithmetic: everything here answers one question — *may this declaration
+be scored by an analyzer reading at all?* — and nothing else answers it.
+
+That question has been got wrong five times. `test_analyzer_bridge`
+records the first four, each a ratio published before the comparison
+could be trusted. The fifth, D137, was this: the completeness check took
+a union of concepts across the whole repository while the units it gated
+were scored one at a time, so a C repository holding a single `setup.py`
+had its C declarations scored on two criteria of three. Keeping the
+decision in one module, returning the population rather than a verdict,
+is what stops a sixth from arriving by scoping the check differently
+from the thing it gates.
+"""
+from __future__ import annotations
+
+import posixpath
+from collections import defaultdict
+from pathlib import PurePosixPath
+
+from ._metrics_types import KNOWN_SOURCE_SUFFIXES, Measurement
+
+# The concepts the `declarations` dimension needs, and the rubric
+# thresholds that decide a breach. All three, because `function_status`
+# fails a declaration on **lines OR complexity OR cognitive complexity**
+# — a bridge counting only complexity measures something narrower and
+# cannot be compared against it. Three ratios were quoted from that
+# mistake before a test comparing every criterion caught it.
+DECLARATION_CRITERIA: tuple[tuple[str, str, str], ...] = (
+    ("cyclomatic_complexity", "warn_complexity", "max_complexity"),
+    ("declaration_lines", "warn_function_lines", "max_function_lines"),
+    ("cognitive_complexity", "warn_cognitive_complexity", "max_cognitive_complexity"),
+)
+
+# Dimensions an analyzer can supply at all. `file_size` needs per-file
+# line counts no permissively-licensed tool in the pool reports, and
+# `risk` and `gates` are configured policy with no external equivalent.
+ANALYZER_DIMENSIONS: tuple[str, ...] = ("declarations",)
+
+
+def declaration_concepts_missing(covered: set[str]) -> tuple[str, ...]:
+    """Criteria the analyzers did not supply, in rubric order.
+
+    The fallback this decides is correct and used to be silent, which P8
+    forbids: the reader saw a declarations rate with nothing saying what
+    produced it. It is not a rare path either. lizard reports cyclomatic
+    complexity and declaration lines and no cognitive complexity, so a
+    JavaScript repository with lizard installed and nothing else takes
+    this branch on *every* run -- by construction, and an audit had to
+    point out that the page justifying JavaScript support credited the
+    analyzer pool for work the built-in scanner was doing.
+    """
+    return tuple(
+        concept for concept, _warn, _fail in DECLARATION_CRITERIA
+        if concept not in covered
+    )
+
+
+def _unit_languages(measurements: list[Measurement]) -> dict[str, str]:
+    """Each unit's language, by the suffix of the file it was read from.
+
+    Units whose suffix names no language this project knows are left out
+    rather than pooled under one unknown bucket. The gate below asks
+    whether a *language* is missing a criterion, and a question about a
+    language cannot be asked of a file whose language was never
+    established — pooling them would let `pmd`'s XML readings, which
+    carry no declaration lines, fail the check for a Java repository
+    that is otherwise completely measured.
+    """
+    languages: dict[str, str] = {}
+    for measurement in measurements:
+        path = measurement.path or measurement.unit
+        suffix = PurePosixPath(path).suffix
+        language = KNOWN_SOURCE_SUFFIXES.get(suffix)
+        if language:
+            languages[measurement.unit] = language
+    return languages
+
+
+def _concepts_by_language(
+    per_unit: dict[str, dict[str, float]], unit_languages: dict[str, str]
+) -> dict[str, set[str]]:
+    """What the analyzers measured, gathered per language."""
+    covered: dict[str, set[str]] = defaultdict(set)
+    for unit, values in per_unit.items():
+        language = unit_languages.get(unit)
+        if language:
+            covered[language].update(values)
+    return dict(covered)
+
+
+def _languages_missing_a_criterion(
+    per_unit: dict[str, dict[str, float]], unit_languages: dict[str, str]
+) -> tuple[tuple[str, tuple[str, ...]], ...]:
+    """Languages the analyzers did not measure on all three criteria.
+
+    One incomplete language disqualifies the whole reading, because the
+    value returned here replaces the built-in `declarations` pressure for
+    the entire repository — there is no seam to hand back a blend. Making
+    that seam is a larger change: the built-in path carries one aggregate
+    `declaration_band_pressure`, not a per-language one, so a genuine
+    per-language blend needs per-language aggregates plumbed through the
+    summary. Recorded rather than attempted here, because the honest
+    intermediate is to fall back for the repository when any language it
+    would speak for is incomplete, which is strictly more correct than
+    speaking for all of them on the strength of one.
+    """
+    return tuple(
+        (language, missing)
+        for language, concepts in sorted(
+            _concepts_by_language(per_unit, unit_languages).items())
+        if (missing := declaration_concepts_missing(concepts))
+    )
+
+
+def complete_from_built_ins(
+    per_unit: dict[str, dict[str, float]],
+    unit_locations: dict[str, tuple[str, int]],
+    built_in: dict[tuple[str, int], dict[str, float]],
+) -> dict[str, dict[str, float]]:
+    """Fill criteria an analyzer did not measure from the built-in reading.
+
+    **Per concept, not per dimension.** The rule above asks whether a
+    language carries all three criteria; this is what lets a language
+    answer yes when no single tier measures all three. `lizard` reports
+    cyclomatic complexity and declaration lines for sixteen languages and
+    cognitive complexity for none; the built-in scanners report all three
+    for fourteen. Neither tier is complete alone, and the union of them,
+    per declaration, is.
+
+    Without this the analyzer tier can drive `declarations` for **Python
+    and nothing else** — measured, not inferred: of the 112 corpus
+    repositories, zero satisfied the criterion set without `complexipy`,
+    which reads Python only. PMD is the sole other wired tool that speaks
+    cognitive complexity, and it emits *violations above a threshold*
+    rather than a reading per declaration, so it can never supply a rate
+    over a population.
+
+    The join is `(path, start_line)`, and it is exact rather than
+    approximate: measured on this package, all 1,008 declarations lizard
+    reports match a built-in declaration at the same start line — 100% of
+    lizard's population, 92% of the built-in's, the difference being
+    declarations lizard does not count as functions.
+
+    Mixing tiers inside one unit is the point rather than a compromise.
+    The comparability the criterion set protects is that every
+    declaration was *eligible* to fail on all three, not that one
+    instrument measured all three; ADR 006 already makes the analyzer
+    primary for what it measures, and the bands both tiers are scored
+    through come from the same thresholds.
+    """
+    completed: dict[str, dict[str, float]] = {}
+    for unit, values in per_unit.items():
+        missing = declaration_concepts_missing(set(values))
+        if not missing:
+            completed[unit] = values
+            continue
+        location = unit_locations.get(unit)
+        fallback = built_in.get(location) if location else None
+        filled = dict(values)
+        for concept in missing:
+            if fallback and concept in fallback:
+                filled[concept] = fallback[concept]
+        if declaration_concepts_missing(set(filled)):
+            # No counterpart in the scanner's reading, so this
+            # declaration is not scoreable on the full criterion set by
+            # either tier — and it is dropped rather than left to
+            # disqualify its language.
+            #
+            # Measured, because the alternative looked reasonable and was
+            # not: `lizard` reads files the built-in scanner produces no
+            # declarations for — Alamofire's `docs/js/jquery.min.js` and
+            # `jazzy.js`, five generated documentation assets. Keeping
+            # them gave JavaScript a bucket that could never be completed
+            # and took the whole repository to the built-in tier, Swift
+            # and all. The same shape hid Java behind a repository's
+            # bundled `.js`.
+            #
+            # Dropping them also aligns the two populations: a unit the
+            # scanner never read is not in the built-in rate either, so
+            # including it in the analyzer rate compares a wider
+            # population against a narrower one.
+            continue
+        completed[unit] = filled
+    return completed
+
+
+def built_in_readings(
+    metrics: object, root: str = ""
+) -> dict[tuple[str, int], dict[str, float]]:
+    """The scanner's three criteria per declaration, keyed for the join.
+
+    Lives beside the join rather than at the call site so both halves of
+    it share one path vocabulary. They did not, once, and the merge
+    shipped inert with the whole suite green.
+    """
+    return {
+        (canonical_path(root, metric.path), metric.start_line): {
+            "cyclomatic_complexity": float(metric.complexity),
+            "declaration_lines": float(metric.lines),
+            "cognitive_complexity": float(metric.cognitive),
+        }
+        for metric in metrics  # type: ignore[attr-defined]
+    }
+
+
+def canonical_path(root: str, path: str) -> str:
+    """One spelling for a file, so two tiers can be joined on it.
+
+    Three vocabularies meet at this join and no two agree: `lizard`
+    reports `./src/x.py`, `complexipy` reports the absolute path, and the
+    built-in scanner reports `src/x.py` relative to the scanned root.
+    Keying the join on any of them as given matches nothing, which is not
+    a hypothetical — it is how this merge shipped inert the first time,
+    with the whole suite green, because every test built both sides from
+    the same string.
+    """
+    text = path.replace("\\", "/")
+    if root and text.startswith(root):
+        text = text[len(root):]
+    return posixpath.normpath(text).lstrip("./") or text
+
+
+def unit_locations(
+    measurements: list[Measurement], root: str = ""
+) -> dict[str, tuple[str, int]]:
+    """Where each unit starts, for the join above.
+
+    A measurement with no line cannot be joined and is simply absent
+    here: `complexipy` reports no start line, and needs none, because it
+    supplies the one concept the built-in tier would have been asked for.
+    """
+    located: dict[str, tuple[str, int]] = {}
+    for measurement in measurements:
+        path = measurement.path or ""
+        if path and measurement.line is not None:
+            located[measurement.unit] = (
+                canonical_path(root, path), int(measurement.line))
+    return located
+
+
+def _scored_units(
+    per_unit: dict[str, dict[str, float]], unit_languages: dict[str, str]
+) -> dict[str, dict[str, float]] | None:
+    """The declarations the analyzer tier may score, or `None` for none.
+
+    **The one place eligibility is decided.** The rule it enforces is a
+    single sentence, and it is the sentence this bridge exists to keep
+    true: *every declaration contributing to the analyzer reading was
+    eligible to fail on all three criteria the built-in path fails on.*
+    A unit is eligible when its own language was measured on cyclomatic
+    complexity, declaration lines and cognitive complexity — not when
+    some other language in the repository was.
+
+    Returning the population rather than a verdict is the point. Four
+    earlier fixes to this bridge each corrected a formula and left the
+    eligibility question living somewhere else, and D137 was the fifth:
+    the check took a union across the repository while the units it
+    gated were scored one at a time, so a C repository holding one
+    `setup.py` had its C declarations scored on two criteria of three.
+    A caller cannot now score a set this function did not hand back, so
+    the two cannot be scoped differently again.
+
+    The verdict is all-or-nothing for the repository because the value
+    the caller produces replaces the built-in `declarations` pressure for
+    the whole of it; there is no seam to hand back a blend. Handing back
+    only the eligible units would trade a wrong-criteria reading for a
+    wrong-population one — a confident rate describing the 2% of a C
+    codebase that happens to be Python. A genuine per-language blend
+    needs per-language aggregates plumbed through the summary evidence,
+    which the built-in path does not carry today.
+    """
+    incomplete = _languages_missing_a_criterion(per_unit, unit_languages)
+    if incomplete:
+        return None
+    return per_unit

{maintainability_agent-2.11.2 → maintainability_agent-3.0.0}/src/maintainability_audit/_formula.py

@@ -173,9 +173,19 @@ CATEGORY_ASPECTS: dict[str, dict[str, float]] = {
 ROOT_POPULATIONS: tuple[str, ...] = ("files_scanned", "declarations_scanned")
 
 POPULATION_FLOORS: dict[str, int] = {
-    "files_scanned": 32,
+    # The 180-repo corpus minima (3.0.0), taken from `corpus.json`'s own
+    # `source_files` and `declarations` — the columns the floor test
+    # compares against — rather than from the measurement evidence,
+    # which counts a different population and gave 26 / 164.
+    #
+    # Were 32 / 139 / 36 against the 112-repo corpus. The added languages
+    # brought smaller repositories: SwiftyJSON and fd at 24 source files,
+    # express at 139 declarations. A floor above the corpus minimum is
+    # not a floor, it is a repository the scale cannot score while
+    # claiming to be calibrated by it.
+    "files_scanned": 24,
     "declarations_scanned": 139,
-    "production_declarations_scanned": 36,
+    "production_declarations_scanned": 53,
 }
 
 # Which population each aspect's rate divides by. An aspect absent from