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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maintainability-agent
-Version: 2.1.0
+Version: 2.3.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.3.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.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 **2.1.0**.
+Version **2.3.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.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "maintainability-agent"
-version = "2.1.0"
+version = "2.3.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.3.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.3.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.3.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.3.0}/src/maintainability_agent.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ src/maintainability_audit/__main__.py
 src/maintainability_audit/_adapters.py
 src/maintainability_audit/_analysis.py
 src/maintainability_audit/_aspects.py
+src/maintainability_audit/_attestation.py
 src/maintainability_audit/_backfill.py
 src/maintainability_audit/_bands.py
 src/maintainability_audit/_built_ins.py
@@ -33,6 +34,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 +64,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
@@ -142,6 +145,7 @@ tests/test_artifact_write_route_class.py
 tests/test_aspect_coverage.py
 tests/test_asset_snapshot_class.py
 tests/test_ast_reading_resolves_spellings.py
+tests/test_attestation.py
 tests/test_audit_components.py
 tests/test_authorization_freshness.py
 tests/test_authorship_gates.py
@@ -187,6 +191,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.3.0}/src/maintainability_audit/__init__.py

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

maintainability_agent-2.3.0/src/maintainability_audit/_attestation.py

@@ -0,0 +1,166 @@
+"""The record a generator cannot produce about its own output.
+
+The three mechanisms — scope conformance, suppression detection, the
+dimension ratchet — each answer one question about a change. This composes
+them into the artifact they were built for: a per-change record of what was
+measured, what the agent was told to change, what it actually changed, and
+what moved.
+
+**Why an independent process has to emit it.** A platform that generates
+code and then reports on its quality is producing a self-assessment. That
+is a property of the arrangement, not a criticism of any particular one,
+and no amount of engineering removes it. The question a reviewer asks is
+*who checked this, and can they re-derive the check months from now* — and
+an author cannot be the answer. This tool writes nothing, runs no model,
+and returns the same verdict from the same inputs, which is the only reason
+its answer can be evidence rather than an opinion.
+
+**It is reproducible, not signed.** Every field is derived from the report
+and the pinned inputs, and the digest at the end is over the record's own
+content, so two runs on the same commit with the same analyzer versions
+produce the same digest. That makes it *verifiable* — anyone can re-run and
+compare. It is deliberately not called a signature: nothing here holds a
+key, and claiming a cryptographic guarantee this does not provide would be
+exactly the kind of overclaim the rest of the project spends its time
+removing. Signing the artifact, if a caller wants that, is a step they take
+with their own key on a file whose bytes are stable.
+
+**What it does not establish.** The record says which files the work order
+named and whether a checker was switched off — not whether the edits were
+correct. It never opens the diff to judge it, and it never touches a score.
+Review is still review.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from typing import Any
+
+ARTIFACT_VERSION = 1
+
+
+def _verdicts(report: dict[str, Any]) -> list[str]:
+    """One line per question that was actually asked."""
+    lines: list[str] = []
+    conformance = report.get("scope_conformance")
+    if conformance:
+        out = len(conformance["out_of_scope"])
+        silenced = conformance["suppressions_on_named_paths"]
+        lines.append(
+            f"- **Stayed inside the work order:** "
+            f"{'yes' if conformance['conformant'] else f'no — {out} file(s) outside it'}"
+        )
+        lines.append(
+            f"- **Without silencing a finding:** "
+            f"{'yes' if not silenced else f'no — {silenced} suppression(s) on flagged files'}"
+        )
+    ratchet = report.get("dimension_ratchet")
+    if ratchet:
+        if not ratchet["comparable"]:
+            lines.append(
+                f"- **No dimension regressed:** not established — {ratchet['reason']}"
+            )
+        elif ratchet["regressed"]:
+            names = ", ".join(item["name"] for item in ratchet["regressed"])
+            lines.append(f"- **No dimension regressed:** no — {names}")
+        else:
+            lines.append("- **No dimension regressed:** yes")
+    return lines
+
+
+def _measured(report: dict[str, Any]) -> list[str]:
+    score = report.get("score") or {}
+    coverage = report.get("analyzer_coverage") or {}
+    status = score.get("evidence_status")
+    if isinstance(status, dict):
+        status = status.get("status")
+    ran = (coverage.get("by_outcome") or {}).get("ran") or []
+    return [
+        f"- Estimate: {score.get('maintainability_estimate', 'withheld')}",
+        f"- Verified grade: {score.get('verified_grade') or 'withheld'}",
+        f"- Evidence: {status or 'unstated'}",
+        f"- Analyzers that ran: {len(ran)}",
+        f"- Hard gate failures: {len(report.get('hard_gate_failures') or [])}",
+    ]
+
+
+def attestation_record(report: dict[str, Any]) -> dict[str, Any]:
+    """The structured record, before rendering."""
+    conformance = report.get("scope_conformance") or {}
+    ratchet = report.get("dimension_ratchet") or {}
+    score = report.get("score") or {}
+    record = {
+        "artifact_version": ARTIFACT_VERSION,
+        "tool_version": report.get("tool_version"),
+        "commit": report.get("git_commit"),
+        "branch": report.get("git_branch"),
+        # A finding reported against "the commit" that actually depends on
+        # uncommitted work is unreproducible, so the state of the tree is
+        # part of what is attested rather than a footnote.
+        "tree_dirty": bool(report.get("git_status_short")),
+        "revspec": conformance.get("revspec"),
+        "estimate": score.get("maintainability_estimate"),
+        "verified_grade": score.get("verified_grade"),
+        "stayed_in_scope": conformance.get("conformant"),
+        "no_finding_silenced": (
+            None if not conformance else conformance["suppressions_on_named_paths"] == 0
+        ),
+        "no_dimension_regressed": (
+            None if not ratchet or not ratchet.get("comparable")
+            else not ratchet["regressed"]
+        ),
+        "scope_conformance": conformance or None,
+        "dimension_ratchet": ratchet or None,
+    }
+    # The digest is over the record without it, so it is reproducible: the
+    # same commit measured with the same analyzer versions yields the same
+    # value, and anyone can recompute it rather than trust it.
+    record["digest"] = hashlib.sha256(
+        json.dumps(record, sort_keys=True, default=str).encode("utf-8")
+    ).hexdigest()[:16]
+    return record
+
+
+def render_attestation(report: dict[str, Any]) -> str:
+    """The record as text, for a reviewer or an audit trail."""
+    record = attestation_record(report)
+    dirty = " (uncommitted changes present)" if record["tree_dirty"] else ""
+    lines = [
+        "# Maintainability attestation",
+        "",
+        "An independent, deterministic check on a change. Produced by a "
+        "process that generated none of the code it examined.",
+        "",
+        f"- Commit: `{record['commit'] or 'unknown'}`{dirty}",
+        f"- Branch: `{record['branch'] or 'unknown'}`",
+        f"- Tool version: {record['tool_version'] or 'unknown'}",
+        f"- Compared: `{record['revspec'] or 'not asked'}`",
+        "",
+        "## What was measured",
+        "",
+        *_measured(report),
+        "",
+        "## What the change did",
+        "",
+    ]
+    verdicts = _verdicts(report)
+    lines += verdicts or ["- Nothing was asked: run with `--conformance` and "
+                          "`--fail-on-regression` to populate this section."]
+    lines += [
+        "",
+        "## What this does not establish",
+        "",
+        "- It compares paths and reads added lines. A file in scope means the "
+        "work order named it, **not** that the change to it was correct — this "
+        "never opens the diff to judge it.",
+        "- It touches no score. Whether a change obeyed its instructions is a "
+        "fact about behaviour, not evidence about the code's condition.",
+        "- It is reproducible, **not signed**. The digest is over this "
+        "record's own content, so the same inputs reproduce it and anyone can "
+        "recompute it. Nothing here holds a key.",
+        "",
+        f"Digest: `{record['digest']}`",
+        "",
+    ]
+    return "\n".join(lines)

maintainability_agent-2.3.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.3.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.3.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 "
@@ -86,6 +97,14 @@ def add_arguments(parser: argparse.ArgumentParser) -> None:
     parser.add_argument("--prompt-output", help="Optional Markdown prompt for AI-assisted remediation.")
     parser.add_argument("--comment-output", help="Optional Markdown body suitable for a PR comment.")
     parser.add_argument("--agent-instructions-output", help="Optional reusable instructions for AI coding agents.")
+    parser.add_argument(
+        "--attestation-output",
+        help="Write the attestation: an independent, reproducible record of "
+             "what was measured, what the change was told to do, what it did, "
+             "and what moved. Populated by --conformance and "
+             "--fail-on-regression; a generator cannot produce this about its "
+             "own output.",
+    )
     parser.add_argument("--hostile-prompt-output",
                         help="Optional adversarial audit brief seeded from this run (ADR 013). "
                              "Text only: it does not gate, score, or send anything.")
@@ -216,6 +235,10 @@ def write_outputs(args: argparse.Namespace, report: dict, rendered: str) -> None
         write_artifact(root, Path(args.comment_output), render_pr_comment(report) + "\n")
     if args.agent_instructions_output:
         write_artifact(root, Path(args.agent_instructions_output), render_agent_instructions(report) + "\n")
+    if args.attestation_output:
+        from ._attestation import render_attestation
+
+        write_artifact(root, Path(args.attestation_output), render_attestation(report))
     if args.hostile_prompt_output:
         write_artifact(root, Path(args.hostile_prompt_output),
                        render_hostile_audit_prompt(report) + "\n")
@@ -226,48 +249,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 +306,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 +409,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.3.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.3.0"
 
 PROJECT_URL = "https://github.com/marshallguillory86/maintainability-agent"
 

{maintainability_agent-2.1.0 → maintainability_agent-2.3.0}/src/maintainability_audit/prompts.py

@@ -11,6 +11,7 @@ from __future__ import annotations
 from typing import Any
 
 from . import _evidence_view as view
+from ._attestation import render_attestation  # noqa: F401
 from ._hostile_prompt import render_hostile_audit_prompt  # noqa: F401
 from ._hotspots import hotspot_measure, hotspot_name
 from ._tdd_view import tdd_sentences