maintainability-agent 2.7.0__tar.gz → 2.8.0__tar.gz

{maintainability_agent-2.7.0/src/maintainability_agent.egg-info → maintainability_agent-2.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maintainability-agent
-Version: 2.7.0
+Version: 2.8.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.7.0**.
+Version **2.8.0**.
 
 **Languages parsed:** Python, Java, C, C++, C#, Swift, Fortran (free-form
 *and* fixed-form), and the JS/TS family — each by a scanner written for it, and
@@ -383,8 +383,8 @@ Based on ISO/IEC 25010 maintainability — modularity, reusability,
 analyzability, modifiability, testability. Scores are **rates calibrated
 against real code**, not counts: every pressure is normalized against the
 median a pinned 112-repo corpus of mature projects actually carries —
-spanning every language the scanner parses (django, angular, spring-framework,
-ghidra, LAPACK, …). How that corpus was selected, what each language actually
+eight of the ten parsed languages (django, angular, spring-framework,
+ghidra, LAPACK, …); Swift and COBOL are parsed but unanchored. How that corpus was selected, what each language actually
 reads, and what the numbers do *not* establish:
 [the calibration study](docs/calibration-2.0-study.md), so `2.5x` means
 "two and a half times what well-maintained real code shows." The corpus median

{maintainability_agent-2.7.0 → maintainability_agent-2.8.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.7.0**.
+Version **2.8.0**.
 
 **Languages parsed:** Python, Java, C, C++, C#, Swift, Fortran (free-form
 *and* fixed-form), and the JS/TS family — each by a scanner written for it, and
@@ -344,8 +344,8 @@ Based on ISO/IEC 25010 maintainability — modularity, reusability,
 analyzability, modifiability, testability. Scores are **rates calibrated
 against real code**, not counts: every pressure is normalized against the
 median a pinned 112-repo corpus of mature projects actually carries —
-spanning every language the scanner parses (django, angular, spring-framework,
-ghidra, LAPACK, …). How that corpus was selected, what each language actually
+eight of the ten parsed languages (django, angular, spring-framework,
+ghidra, LAPACK, …); Swift and COBOL are parsed but unanchored. How that corpus was selected, what each language actually
 reads, and what the numbers do *not* establish:
 [the calibration study](docs/calibration-2.0-study.md), so `2.5x` means
 "two and a half times what well-maintained real code shows." The corpus median

{maintainability_agent-2.7.0 → maintainability_agent-2.8.0}/pyproject.toml

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maintainability-agent
-Version: 2.7.0
+Version: 2.8.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.7.0**.
+Version **2.8.0**.
 
 **Languages parsed:** Python, Java, C, C++, C#, Swift, Fortran (free-form
 *and* fixed-form), and the JS/TS family — each by a scanner written for it, and
@@ -383,8 +383,8 @@ Based on ISO/IEC 25010 maintainability — modularity, reusability,
 analyzability, modifiability, testability. Scores are **rates calibrated
 against real code**, not counts: every pressure is normalized against the
 median a pinned 112-repo corpus of mature projects actually carries —
-spanning every language the scanner parses (django, angular, spring-framework,
-ghidra, LAPACK, …). How that corpus was selected, what each language actually
+eight of the ten parsed languages (django, angular, spring-framework,
+ghidra, LAPACK, …); Swift and COBOL are parsed but unanchored. How that corpus was selected, what each language actually
 reads, and what the numbers do *not* establish:
 [the calibration study](docs/calibration-2.0-study.md), so `2.5x` means
 "two and a half times what well-maintained real code shows." The corpus median

{maintainability_agent-2.7.0 → maintainability_agent-2.8.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/_anchor.py
 src/maintainability_audit/_arguments.py
 src/maintainability_audit/_aspects.py
 src/maintainability_audit/_attestation.py
@@ -143,6 +144,7 @@ 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_anchor_disclosure.py
 tests/test_annotations_match_behaviour.py
 tests/test_anticipated_refusals.py
 tests/test_architecture.py
@@ -283,6 +285,7 @@ tests/test_runner.py
 tests/test_sarif.py
 tests/test_scan_history.py
 tests/test_scan_scope.py
+tests/test_scanner_unsafe_direction.py
 tests/test_scanning.py
 tests/test_schema_fidelity.py
 tests/test_scope_conformance.py
@@ -302,6 +305,7 @@ tests/test_tdd_structure.py
 tests/test_test_commands.py
 tests/test_test_execution_class.py
 tests/test_three_presentations.py
+tests/test_tree_chosen_spawn.py
 tests/test_trends.py
 tests/test_type_fields_not_functions_class.py
 tests/test_uat_falsifiers.py

{maintainability_agent-2.7.0 → maintainability_agent-2.8.0}/src/maintainability_audit/__init__.py

@@ -1,3 +1,3 @@
 """Maintainability Audit CI."""
 
-__version__ = "2.7.0"
+__version__ = "2.8.0"

maintainability_agent-2.8.0/src/maintainability_audit/_anchor.py

@@ -0,0 +1,49 @@
+"""What the reference corpus does not hold, and how to say it.
+
+Rubric data, like `_calibration`: a fact about the anchor rather than a
+computation over a repository. It lives beside the constant it qualifies
+because the two go stale together — a recalibration that adds Swift and
+COBOL to the corpus empties this in the same commit that moves
+`CALIBRATION_C`.
+
+**Unanchored is policy, not an oversight.** Under the corpus policy
+decided with 2.4.1, a language ships parsed and the corpus is re-measured
+once after the remaining scanners land: adding a scanner moves
+`scanner_fingerprint` and invalidates every stored measurement, so paying
+per language means paying in full, repeatedly, for an anchor that is
+obsolete again at the next one.
+
+What is *not* policy is silence about it where the grade is read. The
+report carried `score.reference` and the note said the corpus spanned
+"every language this scanner parses" — which was true when it was written
+and false from 2.4.0 onward, for three releases. A Grok audit on
+2026-09-04 named it as the second instance of a shape this project had
+already shipped once: a limit disclosed only in JSON is disclosed nowhere
+that matters.
+"""
+from __future__ import annotations
+
+#: Parsed by a scanner, absent from the reference corpus.
+#:
+#: Stated rather than derived. `tools/calibration/corpus.json` is a
+#: repository file and does not ship in the wheel, so a runtime read would
+#: be unavailable exactly where a user reads a grade.
+#: `test_anchor_disclosure` recomputes `parsed - corpus` from both sources
+#: and fails if this stops matching, so the list cannot quietly go stale.
+UNANCHORED_LANGUAGES: tuple[str, ...] = ("Swift", "COBOL")
+
+
+def unanchored_names() -> str:
+    """The languages, joined for a sentence. Empty when there are none."""
+    return " and ".join(UNANCHORED_LANGUAGES)
+
+
+def unanchored_sentence() -> str:
+    """One sentence naming what the anchor omits, for the corpus note."""
+    if not UNANCHORED_LANGUAGES:
+        return ""
+    return (
+        f"{unanchored_names()} are parsed but absent from it, so their "
+        "findings are as good as their parser while their grade is "
+        "provisional."
+    )

{maintainability_agent-2.7.0 → maintainability_agent-2.8.0}/src/maintainability_audit/_assets/standard.md

@@ -132,10 +132,22 @@ about LAPACK relative to mature OSS *web* code, and not a statement about
 typical Fortran, because no typical Fortran was in the comparison set.
 
 **2.0.0 extended the corpus rather than the caveat.** It is now 112
-repositories spanning every language this scanner parses: Python,
-TypeScript, JavaScript, Java, C, C++, C# and Fortran. The original 40 rows
-are unchanged and still pinned to the commits they were measured at, so
-what moved the constants is the languages added and nothing else.
+repositories spanning eight languages: Python, TypeScript, JavaScript,
+Java, C, C++, C# and Fortran. The original 40 rows are unchanged and still
+pinned to the commits they were measured at, so what moved the constants
+is the languages added and nothing else.
+
+**Two parsed languages are not in it.** Swift (2.4.0) and COBOL (2.7.0)
+shipped after that measurement and are **unanchored**: a scanner reads
+them, and the medians their rates are compared against were measured on
+other languages. This is the corpus policy decided with 2.4.1 — a
+language ships parsed, and the corpus is re-measured once after the
+remaining scanners land, because a new scanner moves
+`scanner_fingerprint` and invalidates every stored row. The cost is
+disclosed rather than absorbed: findings in those languages are as good
+as their parser, their grade is provisional, and every surface that
+prints a grade says so. This sentence read "every language this scanner
+parses" for three releases after it stopped being true.
 
 Three limits remain, and they are narrower than the one they replace:
 

{maintainability_agent-2.7.0 → maintainability_agent-2.8.0}/src/maintainability_audit/_cognitive.py

@@ -35,11 +35,11 @@ import re
 
 from ._masking import mask_fortran_lines, mask_lines
 
-# Both live in `parsing`, and `_ranges_core` reaches nothing here, so this
-# is a sibling import rather than a cycle. COBOL's mask is not in
-# `_masking` with the others because it needs the whole file to know which
-# division a line is in — see `_ranges_cobol.mask_cobol_lines`.
-from ._ranges_cobol import mask_cobol_lines
+# No COBOL masker is imported here, deliberately: `cobol_cognitive` takes
+# lines that are already masked. COBOL's mask is the only file-level one —
+# what a line means depends on which division it sits in — so re-masking
+# the paragraph slice `detect_functions` hands over blanked it entirely
+# and scored every COBOL paragraph 0. See `cobol_cognitive`.
 
 # Constructs that both cost a point and deepen the nesting for whatever
 # they contain.
@@ -207,8 +207,18 @@ def cobol_cognitive(lines: list[str]) -> int:
     a call and opens nothing; `PERFORM UNTIL DONE` is a loop and does.
     Counting every `PERFORM` as nesting would make an ordinary
     call-per-line paragraph read as deeply nested.
+
+    **Takes lines that are already masked, and does not mask them again.**
+    Every other reader here may re-mask freely because its masker is
+    line-local; COBOL's is the only file-level one, since deciding what a
+    line means requires knowing which division it sits in. `detect_functions`
+    hands this a *slice* of the masked file, and a paragraph slice contains
+    no `PROCEDURE DIVISION` — so re-masking blanked the whole thing and
+    every COBOL paragraph in production scored exactly 0, including deeply
+    nested ones. The souvenir test passed throughout because it called this
+    with a whole file. Found by a Grok audit on 2026-09-04.
     """
-    masked = mask_cobol_lines(lines)
+    masked = lines
     score = 0
     depth = 0
     for line in masked:

{maintainability_agent-2.7.0 → maintainability_agent-2.8.0}/src/maintainability_audit/_evidence_view.py

@@ -339,3 +339,33 @@ def test_suite_lines(block: dict[str, Any] | None) -> list[str]:
     if detail and not block.get("passed"):
         lines.append(f"Detail: {detail}")
     return lines
+
+
+def unanchored_languages(score: dict[str, Any]) -> tuple[str, ...]:
+    """Parsed languages the reference corpus does not hold, from the report.
+
+    Read off `score.reference` rather than imported from `_anchor`, so a
+    report rendered from stored JSON discloses what *that* run's anchor
+    omitted rather than what today's build omits.
+    """
+    return tuple((score.get("reference") or {}).get("unanchored_languages") or ())
+
+
+def unanchored_caveat(score: dict[str, Any]) -> list[str]:
+    """The anchor's gap, in one sentence, for any skin that prints a grade.
+
+    Lives here because all three skins were about to carry their own copy
+    of the same lookup and the same sentence. `score.reference` rides on
+    the JSON report, and the JSON is not what most people read — a limit
+    disclosed only there is disclosed nowhere that matters, which is the
+    shape this project already shipped once as F1.
+    """
+    names = unanchored_languages(score)
+    if not names:
+        return []
+    return ["", (
+        f"*{' and '.join(names)} are parsed but are not in the reference "
+        "corpus, so a grade or multiple reported for code in them is "
+        "provisional: the findings are as good as the parser, the rate "
+        "they are compared against was measured on other languages.*"
+    ), ""]

{maintainability_agent-2.7.0 → maintainability_agent-2.8.0}/src/maintainability_audit/_html_view.py

@@ -89,6 +89,16 @@ def render_html(report: dict[str, Any], records: list[Any]) -> str:
     return "\n".join(parts)
 
 
+def _unanchored_html(score: dict[str, Any]) -> list[str]:
+    """The anchor's gap, beside the letter rather than only in the JSON."""
+    names = view.unanchored_languages(score)
+    if not names:
+        return []
+    return [f"<div class='caveat'>{escape(' and '.join(names))} are parsed but "
+            "are not in the reference corpus, so a grade for code in them is "
+            "provisional.</div>"]
+
+
 def _executive_strip(report: dict[str, Any], score: dict[str, Any],
                      records: list[Any]) -> list[str]:
     """The result, the gate, the finding counts, the direction. First."""
@@ -110,6 +120,7 @@ def _executive_strip(report: dict[str, Any], score: dict[str, Any],
         f"Source: {escape(view.estimate_source(score))}</div>",
         f"<div>{escape(view.status_sentence(score, report.get('analyzer_coverage') is not None))}</div>",
         f"<div>{gate}</div>",
+        *_unanchored_html(score),
         f"<div>{escape(_direction_sentence(records))}</div>",
         "<table><tr><th>Severity</th><th>Findings</th></tr>",
         *count_rows,

{maintainability_agent-2.7.0 → maintainability_agent-2.8.0}/src/maintainability_audit/_masking.py

@@ -254,3 +254,47 @@ def mask_lines(lines: list[str]) -> list[str]:
         text, in_block, in_template = _mask_line(line, in_block, in_template)
         masked.append(text)
     return masked
+
+
+#: Swift's multiline literal, in both spellings: `"""` and the raw form
+#: `#"""` … `"""#` (any number of `#`). Matched loosely on purpose — the
+#: delimiter is what matters, not how many hashes surround it.
+_SWIFT_MULTILINE_RE = re.compile(r'#*"""#*')
+
+
+def mask_swift_lines(lines: list[str]) -> list[str]:
+    """Swift, with multiline string literals blanked before anything reads it.
+
+    `mask_lines` is line-local: it blanks `"a"` on the line it appears on
+    and knows nothing about a literal that spans lines. Swift's
+    triple-quoted block therefore survived it, and every line between the
+    delimiters was read as code — so a `func` written inside a
+    documentation string came back as a declaration, with a name, a length
+    and a complexity nobody wrote.
+
+    `_ranges_java` discloses exactly this hole for Java text blocks. It is
+    disclosed there and closed here rather than copied: Swift's multiline
+    strings carry sample code far more often than Java's, and a
+    declaration invented out of documentation is the P7 failure — a number
+    a reader with the file in front of them would call absurd.
+
+    The delimiter lines keep their own text up to and after the marker, so
+    `let a = \"\"\"` still reads as an assignment. Length is preserved per
+    line, as everywhere else here, or every range after the literal would
+    shift.
+    """
+    masked: list[str] = []
+    inside = False
+    for line in lines:
+        out = []
+        position = 0
+        for match in _SWIFT_MULTILINE_RE.finditer(line):
+            segment = line[position:match.start()]
+            out.append(" " * len(segment) if inside else segment)
+            out.append(match.group(0))
+            inside = not inside
+            position = match.end()
+        rest = line[position:]
+        out.append(" " * len(rest) if inside else rest)
+        masked.append("".join(out))
+    return mask_lines(masked)

{maintainability_agent-2.7.0 → maintainability_agent-2.8.0}/src/maintainability_audit/_ranges_cobol.py

@@ -72,11 +72,21 @@ _SECTION_RE = re.compile(r"^\s{0,3}([A-Za-z0-9][A-Za-z0-9-]*)\s+SECTION\s*\.", r
 #: paragraph headers in columns 8-11 (Area A) and statements in 12-72
 #: (Area B); after the sequence and indicator columns are stripped, Area A
 #: is offset 0-3 and Area B begins at offset 4 — which is why the bound is
-#: three spaces and not four. A statement is therefore indented past this
-#: pattern and cannot be read as a paragraph. Written `{0,4}` first, and a
-#: masked `DISPLAY "A".` sitting at column 12 came straight back as a
-#: declaration named DISPLAY — one per statement in the file.
-_PARAGRAPH_RE = re.compile(r"^\s{0,3}([A-Za-z0-9][A-Za-z0-9-]*)\s*\.\s*$")
+#: three spaces and not four. Written `{0,4}` first, and a masked
+#: `DISPLAY "A".` sitting at column 12 came straight back as a declaration
+#: named DISPLAY — one per statement in the file.
+#:
+#: **The period abuts the name**, and that is the load-bearing half. Area A
+#: only separates a header from an *indented* statement; free-form COBOL
+#: writes statements in column 1 too, and once `"A"` is blanked to spaces
+#: `DISPLAY "A".` is a word, a gap, and a period — the exact shape of a
+#: header. The gap is what gives it away, because a real header has
+#: nothing between its name and its period. That rejects the whole class
+#: of operand-bearing statements (`CALL "SUB".`, `MOVE 1 TO X.`) rather
+#: than a list of verbs, which would need a new entry per verb forever.
+#: `_STATEMENT_WORDS` still covers the operand-*less* ones, where no gap
+#: exists to see.
+_PARAGRAPH_RE = re.compile(r"^\s{0,3}([A-Za-z0-9][A-Za-z0-9-]*)\.\s*$")
 _DIVISION_RE = re.compile(r"^\s*[A-Za-z0-9-]+\s+DIVISION\s*\.", re.I)
 _PROCEDURE_RE = re.compile(r"^\s*PROCEDURE\s+DIVISION\b", re.I)
 _END_PROGRAM_RE = re.compile(r"^\s*END\s+PROGRAM\b", re.I)

{maintainability_agent-2.7.0 → maintainability_agent-2.8.0}/src/maintainability_audit/_ranges_swift.py

@@ -41,6 +41,7 @@ from __future__ import annotations
 
 import re
 
+from ._masking import mask_swift_lines
 from ._metrics_types import DeclRange
 from ._ranges_core import _mask_generics, scan_bounded
 
@@ -160,7 +161,11 @@ def swift_declaration_ranges(lines: list[str]) -> tuple[list[DeclRange], list[st
       disabled `#if` arm still counts.
     """
     ranges, masked = scan_bounded(
-        lines, _swift_declaration, descend=("class",), skip_preprocessor=True
+        lines, _swift_declaration, descend=("class",), skip_preprocessor=True,
+        # Multiline literals are blanked before anything reads a line. The
+        # default line-local mask left a `func` inside a `"""` block
+        # looking like a declaration — see `mask_swift_lines`.
+        mask=mask_swift_lines,
     )
     return _qualify_extension_members(ranges, masked), masked
 

{maintainability_agent-2.7.0 → maintainability_agent-2.8.0}/src/maintainability_audit/_semantic_ts.py

@@ -66,10 +66,11 @@ def local_tsc_analysis(root: Path) -> dict[str, Any] | None:
     Runs across the repository root *and* any workspace beneath it that
     carries a `tsconfig.json` — TS monorepos keep the config in `web/` or
     `packages/*`, not the root, and a root-only check went blind on exactly
-    the repos this is for. Uses a `tsc` that is already present: the
-    workspace's own `node_modules/.bin/tsc`, the root's, or one on the PATH.
-    Never installs, never runs `npx --yes`, never touches the network — a
-    project-local compiler is the standard install, not an acquisition.
+    the repos this is for. Uses a `tsc` **this machine** already provides,
+    found on PATH. Never installs, never runs `npx --yes`, never touches
+    the network — and never the audited tree's own
+    `node_modules/.bin/tsc`, which would let the repository choose the
+    binary this process runs (Decision 9; see `_tsc_on_path`).
 
     An absent checker, or a `tsc` that cannot run usably, leaves coverage
     *unknown*, not clean: a config error (FAILED, exit 3+) or a findings
@@ -81,13 +82,14 @@ def local_tsc_analysis(root: Path) -> dict[str, Any] | None:
     """
     diagnostics: list[dict[str, Any]] = []
     ran = False
+    if not _tsc_on_path():
+        return None
     for project in _tsconfig_project_dirs(root):
-        tsc = _resolve_tsc(root, project)
-        if tsc is None:
-            continue
         result = run(
             "typescript",
-            Invocation(argv=(tsc, "--noEmit", "--pretty", "false"),
+            # A constant, resolved by PATH. Never a path built from the
+            # audited tree — see `_tsc_on_path`.
+            Invocation(argv=("tsc", "--noEmit", "--pretty", "false"),
                        findings_exit_codes=(0, 1, 2)),
             cwd=project,
         )
@@ -125,14 +127,28 @@ def _tsconfig_project_dirs(root: Path) -> list[Path]:
     return sorted(dirs)
 
 
-def _resolve_tsc(root: Path, project: Path) -> str | None:
-    """An already-installed `tsc`: the workspace's own, then the root's,
-    then one on the PATH. Never installs and never fetches."""
-    for base in (project, root):
-        local = base / "node_modules" / ".bin" / "tsc"
-        if local.is_file():
-            return str(local)
-    return "tsc" if locate("tsc") else None
+def _tsc_on_path() -> bool:
+    """Whether a `tsc` **this machine** provides is available.
+
+    PATH only, and that is the whole point. This preferred the audited
+    tree's own `node_modules/.bin/tsc` and fell back to PATH, which let
+    the repository under audit choose the binary this process executes —
+    a `tsconfig.json` and a writable `node_modules/.bin/tsc` are all a
+    hostile tree needs, and it does not even have to contain TypeScript.
+
+    SECURITY.md says the sole path by which this agent executes code from
+    the tree is the operator's opt-in test command (Decision 9). That was
+    false while this function existed, so the resolution is deleted
+    rather than guarded: there is no safe way to run a binary whose
+    identity the audited repository controls.
+
+    The cost is disclosed and small. A project whose only compiler is
+    project-local now leaves type coverage **unknown** rather than clean,
+    which is the honest fallback the evidence model already has a word
+    for — and reading an absent checker as a clean one is the
+    absence-as-a-pass this module's own docstring forbids.
+    """
+    return locate("tsc") is not None
 
 
 def _parse_diagnostics(stdout: str, prefix: Path) -> list[dict[str, Any]]:

{maintainability_agent-2.7.0 → maintainability_agent-2.8.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.7.0"
+VERSION = "2.8.0"
 
 PROJECT_URL = "https://github.com/marshallguillory86/maintainability-agent"
 

{maintainability_agent-2.7.0 → maintainability_agent-2.8.0}/src/maintainability_audit/prompts.py

@@ -258,13 +258,14 @@ def prompt_pressure_section(score: dict[str, Any]) -> list[str]:
          if value is not None and value > 1.0),
         key=lambda item: -item[1],
     )
-    lines: list[str] = []
+    # Unanchored languages are provisional here too, elevated or not.
+    lines: list[str] = view.unanchored_caveat(score)
     if elevated:
         lines.extend(
             [
                 "Where this repo is worse than typical real-world code",
-                "(1.0x = the median of a mature open-source corpus of Python, TypeScript "
-                "and JavaScript; only elevated dimensions are listed):",
+                "(1.0x = the median of a mature open-source corpus of eight "
+                "of the ten parsed languages; elevated dimensions only):",
                 "",
             ]
         )

{maintainability_agent-2.7.0 → maintainability_agent-2.8.0}/src/maintainability_audit/renderers.py

@@ -63,6 +63,7 @@ def summary_table(summary: dict[str, int], score: dict[str, Any],
         f"| Duplicate blocks | {summary['duplicate_blocks']} |",
         f"| Risk findings | {summary['risk_findings']} |",
         f"| Hard gate failures | {summary['hard_gate_failures']} |",
+        *view.unanchored_caveat(score),
     ]
 
 

{maintainability_agent-2.7.0 → maintainability_agent-2.8.0}/src/maintainability_audit/scoring.py

@@ -37,6 +37,7 @@ from __future__ import annotations
 from math import inf
 from typing import Any
 
+from ._anchor import UNANCHORED_LANGUAGES, unanchored_sentence
 from ._aspects import (
     aspect_scores,
     evidence_aspect_scores,
@@ -415,9 +416,12 @@ def _reference_block() -> dict[str, object]:
         "corpus_languages": [
             "Python", "TypeScript", "JavaScript", "Java", "C", "C++", "C#", "Fortran",
         ],
+        # Parsed by a scanner, absent from the anchor — see `_anchor`.
+        "unanchored_languages": UNANCHORED_LANGUAGES,
         "corpus_note": (
             "Reference medians are drawn from 112 mature repositories across "
-            "every language this scanner parses. Fortran entered at a lower "
+            "eight of the ten languages this scanner parses. "
+            f"{unanchored_sentence()} Fortran entered at a lower "
             "star threshold than the rest, because its ecosystem has none "
             "above theirs; see docs/standard.md#the-reference-corpus."
         ),