maintainability-agent 3.1.0__tar.gz → 3.3.0__tar.gz

{maintainability_agent-3.1.0/src/maintainability_agent.egg-info → maintainability_agent-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maintainability-agent
-Version: 3.1.0
+Version: 3.3.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 **3.1.0**.
+Version **3.3.0**.
 
 **Planned, not shipped:** the audit tool will become `maintainability-audit`;
 a new `maintainability-agent` companion will run it and automate human-selected

{maintainability_agent-3.1.0 → maintainability_agent-3.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 **3.1.0**.
+Version **3.3.0**.
 
 **Planned, not shipped:** the audit tool will become `maintainability-audit`;
 a new `maintainability-agent` companion will run it and automate human-selected

{maintainability_agent-3.1.0 → maintainability_agent-3.3.0}/pyproject.toml

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maintainability-agent
-Version: 3.1.0
+Version: 3.3.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 **3.1.0**.
+Version **3.3.0**.
 
 **Planned, not shipped:** the audit tool will become `maintainability-audit`;
 a new `maintainability-agent` companion will run it and automate human-selected

{maintainability_agent-3.1.0 → maintainability_agent-3.3.0}/src/maintainability_agent.egg-info/SOURCES.txt

@@ -29,18 +29,21 @@ 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/_delegated_pillar.py
 src/maintainability_audit/_derive.py
 src/maintainability_audit/_discovery.py
 src/maintainability_audit/_documents.py
 src/maintainability_audit/_economics.py
 src/maintainability_audit/_economics_view.py
 src/maintainability_audit/_environment.py
+src/maintainability_audit/_evidence_reader.py
 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/_grammar.py
 src/maintainability_audit/_grant_ledger.py
 src/maintainability_audit/_history_view.py
 src/maintainability_audit/_hostile_prompt.py
@@ -68,6 +71,7 @@ src/maintainability_audit/_precommit.py
 src/maintainability_audit/_precommit_install.py
 src/maintainability_audit/_precommit_view.py
 src/maintainability_audit/_pressures.py
+src/maintainability_audit/_prompt_sections.py
 src/maintainability_audit/_ranges_c.py
 src/maintainability_audit/_ranges_cobol.py
 src/maintainability_audit/_ranges_core.py
@@ -82,6 +86,7 @@ src/maintainability_audit/_ranges_ruby.py
 src/maintainability_audit/_ranges_rust.py
 src/maintainability_audit/_ranges_swift.py
 src/maintainability_audit/_ratchet.py
+src/maintainability_audit/_ratio_adapters.py
 src/maintainability_audit/_recurrence.py
 src/maintainability_audit/_run_comparison.py
 src/maintainability_audit/_runner.py
@@ -186,6 +191,7 @@ tests/test_chat_primary_docs.py
 tests/test_check_refuses_plus_only_fragments.py
 tests/test_checkstyle_adapter.py
 tests/test_checkstyle_catalog.py
+tests/test_child_sandbox.py
 tests/test_ci_history_recipe.py
 tests/test_ci_installs_the_analyzer_pool.py
 tests/test_claimed_languages.py
@@ -212,8 +218,10 @@ tests/test_declaration_edge_cases.py
 tests/test_declaration_grading.py
 tests/test_declaration_ranges.py
 tests/test_declaration_source.py
+tests/test_declarative_parsers.py
 tests/test_declared_authorship.py
 tests/test_declared_imports.py
+tests/test_delegated_security_pillar.py
 tests/test_derivation_mix.py
 tests/test_determinism.py
 tests/test_dimension_ratchet.py
@@ -272,6 +280,7 @@ tests/test_js_declarations.py
 tests/test_language_coverage.py
 tests/test_language_support_honesty.py
 tests/test_mcp_baseline_payload.py
+tests/test_mcp_format_contract.py
 tests/test_mcp_history.py
 tests/test_mcp_server.py
 tests/test_migration_1_0.py
@@ -280,6 +289,7 @@ tests/test_network_disclosure.py
 tests/test_one_setup_across_surfaces_class.py
 tests/test_operator_named_paths.py
 tests/test_operator_named_reads.py
+tests/test_pairing_reads_imports.py
 tests/test_pattern_budget.py
 tests/test_phase6_claims.py
 tests/test_php_declarations.py
@@ -303,6 +313,7 @@ tests/test_python_declarations.py
 tests/test_read_boundary.py
 tests/test_readme_claims.py
 tests/test_recurrence.py
+tests/test_release_needs_an_empty_ledger.py
 tests/test_release_plan.py
 tests/test_release_plan_status.py
 tests/test_report_remedy_copy.py
@@ -334,6 +345,7 @@ tests/test_stage8_contract.py
 tests/test_suite_isolation.py
 tests/test_swift_declarations.py
 tests/test_tdd_structure.py
+tests/test_terminal_asks_the_same_questions.py
 tests/test_test_commands.py
 tests/test_test_execution_class.py
 tests/test_three_presentations.py

{maintainability_agent-3.1.0 → maintainability_agent-3.3.0}/src/maintainability_audit/__init__.py

@@ -1,3 +1,3 @@
 """Maintainability Audit CI."""
 
-__version__ = "3.1.0"
+__version__ = "3.3.0"

{maintainability_agent-3.1.0 → maintainability_agent-3.3.0}/src/maintainability_audit/_anchor.py

@@ -63,8 +63,11 @@ def unanchored_sentence() -> str:
     """One sentence naming what the anchor omits, for the corpus note."""
     if not UNANCHORED_LANGUAGES:
         return ""
+    from ._grammar import agreement
+
+    say = agreement(len(UNANCHORED_LANGUAGES))
     return (
-        f"{unanchored_names()} are parsed but absent from it, so their "
-        "findings are as good as their parser while their grade is "
-        "provisional."
+        f"{unanchored_names()} {say.verb} parsed but absent from it, so "
+        f"{say.possessive} findings are as good as {say.possessive} "
+        f"parser while {say.possessive} grade is provisional."
     )

{maintainability_agent-3.1.0 → maintainability_agent-3.3.0}/src/maintainability_audit/_arguments.py

@@ -120,6 +120,15 @@ def add_arguments(parser: argparse.ArgumentParser) -> None:
     parser.add_argument("--output", help="Output file. Defaults to stdout.")
     _add_artifact_arguments(parser)
     parser.add_argument("--sarif-output", help="Optional SARIF output path for GitHub code scanning.")
+    parser.add_argument(
+        "--security-pillar",
+        help=(
+            "Path to the security-pillar.json secure-code-agent writes with its "
+            "own --security-pillar. ADR 007 delegates the security pillar, and "
+            "this is the document it is read from; defaults to "
+            ".maintainability/security-pillar.json."
+        ),
+    )
     parser.add_argument("--sarif-input", action="append", help="Optional external SARIF file to summarize in reports. Repeatable.")
     parser.add_argument("--changed-only", help="Audit only files changed in a git revspec, for example main...HEAD.")
     parser.add_argument("--baseline", help="Existing baseline JSON. With --fail-on-new, only new findings fail.")

{maintainability_agent-3.1.0 → maintainability_agent-3.3.0}/src/maintainability_audit/_catalog.py

@@ -190,7 +190,23 @@ def decide(tool: dict[str, Any], settings: dict[str, Any]) -> Selection:
     3. the depth, licence and concern tiers.
     """
     slug = tool["slug"]
+    return (
+        _denial(tool, settings)
+        or (Selection(slug, True, "explicitly allowed by name")
+            if slug in settings["allow_tools"] else None)
+        or _tier_decision(tool, settings)
+    )
+
+
+def _denial(tool: dict[str, Any], settings: dict[str, Any]) -> Selection | None:
+    """Step 1: every deny, which beats even an explicit allow.
 
+    `None` means nothing here refused the tool, not that it was admitted —
+    the caller has two more steps. Separate from the tiers because these
+    are the operator's own prohibitions and the tiers are policy: a deny
+    that could be overridden by an allow would not be a deny.
+    """
+    slug = tool["slug"]
     if slug in settings["deny_tools"]:
         return Selection(slug, False, "denied by name")
     if tool["license_class"] in settings["deny_license_classes"]:
@@ -198,10 +214,14 @@ def decide(tool: dict[str, Any], settings: dict[str, Any]) -> Selection:
     denied_concerns = set(tool["upstream_tags"]) & set(settings["deny_concerns"])
     if denied_concerns:
         return Selection(slug, False, f"concern {','.join(sorted(denied_concerns))} denied")
+    return None
 
-    if slug in settings["allow_tools"]:
-        return Selection(slug, True, "explicitly allowed by name")
 
+def _tier_decision(tool: dict[str, Any], settings: dict[str, Any]) -> Selection:
+    """Step 3: the depth, licence and concern tiers, for a tool no deny
+    caught and no allow admitted. The only step that can end in `True`
+    on the tool's own merits."""
+    slug = tool["slug"]
     if tool["deprecated"]:
         return Selection(slug, False, "deprecated upstream")
     if not tool["languages"]:

{maintainability_agent-3.1.0 → maintainability_agent-3.3.0}/src/maintainability_audit/_coverage_notes.py

@@ -59,4 +59,40 @@ def coverage_notes(coverage: dict[str, Any]) -> list[str]:
             "or widen `analyzers.depth`, to have them reported.",
             "",
         ])
+
+    lines.extend(_child_boundary_note(coverage))
     return lines
+
+
+def _child_boundary_note(coverage: dict[str, Any]) -> list[str]:
+    """What this run does not control about the tools it spawned.
+
+    `docs/product-intent.md` has said since P1 was amended that this
+    package "does not sandbox children", and lists *"that third-party
+    tools cannot use the network"* among the things it does not promise.
+    The **report** did not say it. A reader holding a page headed "the
+    analysis itself performs no network access" and a table naming the
+    external tools that ran had no way to learn the second sentence does
+    not cover the first.
+
+    That makes it P8's gap rather than P1's: the promise was correctly
+    scoped all along, and the run relying on that scoping never disclosed
+    it to the person reading the output.
+
+    Only when an external tool actually ran. With no children spawned
+    there is nothing to disclose, and saying it anyway would be the noise
+    this section is careful to avoid.
+    """
+    spawned = coverage.get("tools_contributed") or 0
+    if not spawned:
+        return []
+    return [
+        "**Analyzer children are not network-isolated.** "
+        f"{spawned} external {'tool' if spawned == 1 else 'tools'} ran as local "
+        "child processes. This agent does not transmit the audited source and "
+        "opens no socket of its own, but it does not sandbox what it spawns: a "
+        "third-party analyzer that reaches the network is outside what this run "
+        "controls or observes. Determinism and no upload are the promise; a "
+        "kernel air-gap is not.",
+        "",
+    ]

{maintainability_agent-3.1.0 → maintainability_agent-3.3.0}/src/maintainability_audit/_criteria_scope.py

@@ -154,40 +154,46 @@ def complete_from_built_ins(
     """
     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
+        filled = _completed_unit(values, unit_locations.get(unit), built_in)
+        if filled is not None:
+            completed[unit] = filled
     return completed
 
 
+def _completed_unit(
+    values: dict[str, float],
+    location: tuple[str, int] | None,
+    built_in: dict[tuple[str, int], dict[str, float]],
+) -> dict[str, float] | None:
+    """One declaration's readings, completed from the built-in tier.
+
+    `None` means the union of both tiers still does not cover the
+    criterion set, so this declaration 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.
+    """
+    missing = declaration_concepts_missing(set(values))
+    if not missing:
+        return values
+    fallback = (built_in.get(location) if location else None) or {}
+    filled = dict(values)
+    for concept in missing:
+        if concept in fallback:
+            filled[concept] = fallback[concept]
+    return None if declaration_concepts_missing(set(filled)) else filled
+
+
 def built_in_readings(
     metrics: object, root: str = ""
 ) -> dict[tuple[str, int], dict[str, float]]:

maintainability_agent-3.3.0/src/maintainability_audit/_delegated_pillar.py

@@ -0,0 +1,204 @@
+"""Reading a delegated pillar's own report of itself.
+
+[ADR 007](adr-007-pillars-and-practice.md) makes the five pillars of the
+source framework the top-level taxonomy and declares **Security
+delegated to `secure-code-agent`**, reported as `NotApplicable` so that
+silence is never read as safety. That entry was always a placeholder for
+an artifact that did not exist yet: the other tool measures the pillar,
+so the other tool has to be the one that reports it.
+
+`secure-code-agent` 0.5.0 ships the emitter — `--security-pillar <path>`
+writes `security-pillar.json`, schema `secure-code-agent/security-pillar`
+— and it was built against *this* vocabulary rather than its own. The
+scope words, the two-axis split and the posture matrix with its
+thresholds all come from `_pillars.py`, because two tools saying "level
+3" or "healthy" about one repository have to mean the same thing by it
+or the joined view is worse than either alone.
+
+This module reads the document and checks it is the one expected. The
+*shaping* of the pillar entry lives in `_pillars` beside the entries it
+sits among — scoring may not import a scanner, and reading a path the
+audited tree chooses is what makes this one. Neither half computes a
+number: a delegated pillar's numbers belong to the tool that measured
+them, and a consumer that recomputed anything would be a second opinion
+nobody asked for.
+
+**Absence is the normal case and stays the documented one.** No file
+means the pillar reports exactly what it reported before — delegated,
+`NotApplicable`, naming the other tool. That path is not a failure and
+does not warn: most repositories run one tool.
+
+**A file that cannot be trusted is refused rather than partly believed.**
+Wrong schema, unreadable JSON, a shape that is not an object — each
+returns `None`, and the pillar falls back to the honest placeholder. The
+alternative is a security posture assembled from a document this tool
+does not actually understand, which is worse than no posture at all.
+
+A trailing note on where this sits: it reads a path from the audited
+tree, so it is a scanner rather than part of the rubric.
+`test_scoring_never_imports_scanners_or_assembly` holds that boundary,
+and `report` is what joins the two.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from ._operator_reads import PathNotAllowed, read_source_file
+
+#: Written beside the other artifacts a repository keeps about itself.
+#: The path is a convention rather than a search: a document this tool
+#: trusts for a whole pillar should be somewhere a reader can find, not
+#: wherever a glob happened to match.
+DEFAULT_PILLAR_PATH = ".maintainability/security-pillar.json"
+
+#: The contract this module understands. A document announcing anything
+#: else is refused rather than read hopefully — the schema string is the
+#: producer's promise about the shape, and guessing past it is how a
+#: consumer starts reporting fields that mean something different.
+SCHEMA = "secure-code-agent/security-pillar"
+#: Versions of that contract this tool can read. **Two, deliberately.**
+#: v2 is v1 plus `scoring_model` and nothing else, so a reader that
+#: handles both is not guessing: the producer asserts the key-set
+#: difference is exactly that one field.
+#:
+#: Accepting v2 before the producer emits it is what removes the
+#: deadlock. If MA required v1 while `secure-code-agent` shipped v2,
+#: every document would be refused for the window between the two
+#: releases -- silently, since a refused document reads as no delegated
+#: pillar. Either side can now release first.
+SCHEMA_VERSIONS = frozenset({1, 2})
+
+#: Kept for callers that imported the old name. The gate reads the set.
+SCHEMA_VERSION = 1
+
+#: What the pillar block takes from the document. Named rather than
+#: copied wholesale so a field added upstream cannot silently appear in
+#: this tool's report carrying meaning nobody here has checked.
+CARRIED = (
+    "practice",
+    "condition",
+    "condition_letter",
+    "posture",
+    "verified_grade",
+    "evidence_status",
+    "evidence_reasons",
+    "coverage",
+    "findings_by_severity",
+    "reported_not_scored",
+    "loc_scanned",
+    #: v2. The producer's own identifier for its scoring model, bumped
+    #: when a repository's condition could differ for reasons that are
+    #: not the repository -- normalizer, slope, weights, letter bands,
+    #: the scanner floor, or the built-in rule profile. Absent on v1.
+    #:
+    #: This is what MA keys a delegated trend on, in preference to the
+    #: producer's version, because the version moves on docs releases
+    #: that change no score and fragmenting a trend for those teaches a
+    #: reader to ignore the breaks (D155).
+    "scoring_model",
+)
+
+
+def read_delegated(root: Path, relative: str = DEFAULT_PILLAR_PATH) -> dict[str, Any] | None:
+    """The delegated pillar's own report, or `None` when there is none.
+
+    `None` for every reason a reader might not get a usable document:
+    the file is absent, it is not a regular file, it does not parse, it
+    is not an object, or it announces a schema this tool does not know.
+    All five collapse to one answer because the caller does the same
+    thing with each — keep the placeholder that names the other tool.
+
+    Read through the regular-file primitive like every other path the
+    audited tree chooses (D145): a FIFO here would hang the audit rather
+    than fail it.
+    """
+    path = Path(root) / relative
+    if not path.exists():
+        return None
+    try:
+        payload = json.loads("\n".join(read_source_file(path)))
+    except (OSError, ValueError) as error:
+        if isinstance(error, PathNotAllowed):
+            raise
+        return None
+    if not isinstance(payload, dict):
+        return None
+    if payload.get("schema") != SCHEMA:
+        return None
+    if payload.get("schema_version") not in SCHEMA_VERSIONS:
+        return None
+    return payload if _is_well_formed(payload) else None
+
+
+#: Fields whose *shape* the consumer depends on. A header check alone
+#: accepts any object announcing the right schema, and the pillar then
+#: reads these as if the producer had promised them.
+_SHAPES: tuple[tuple[str, type | tuple[type, ...]], ...] = (
+    ("producer", dict),
+    ("practice", dict),
+    ("condition", (int, float, type(None))),
+    ("posture", (str, type(None))),
+    ("evidence_status", (str, type(None))),
+    ("coverage", (dict, type(None))),
+    ("findings_by_severity", (dict, type(None))),
+    ("reported_not_scored", (dict, type(None))),
+)
+
+#: The postures this tool knows how to render. A document naming one it
+#: does not is refused rather than printed through: the word is the
+#: reader's whole summary of the pillar.
+_POSTURES = frozenset({"healthy", "managed debt", "unmanaged debt", "unverified"})
+
+
+def _is_well_formed(payload: dict[str, Any]) -> bool:
+    """Whether the document's fields are the shapes the pillar reads.
+
+    The header said what the document *claims to be*; this asks whether
+    it is. Checking only `schema` accepted
+    `{"producer": "not-an-object", ...}`, which the pillar then indexed
+    as a mapping and crashed on — a well-formed announcement with a
+    malformed body, which is the shape a header check cannot see.
+
+    Also refused: a `posture` this tool cannot render, and a `posture`
+    the document's own two axes do not support. The second is the one
+    worth stating. `healthy` requires practice at or above
+    `HIGH_PRACTICE` and a condition at or above `GOOD_CONDITION`; a
+    document claiming `healthy` at practice 1 is either a different
+    matrix or a mistake, and either way this tool must not print it.
+    Both tools are supposed to mean the same thing by the word — the
+    consumer is where that is checkable.
+    """
+    for name, kinds in _SHAPES:
+        if name in payload and not isinstance(payload[name], kinds):
+            return False
+    practice = payload.get("practice")
+    if isinstance(practice, dict) and not isinstance(practice.get("level"), int):
+        return False
+    posture = payload.get("posture")
+    if posture is not None and posture not in _POSTURES:
+        return False
+    return _posture_agrees(payload)
+
+
+def _posture_agrees(payload: dict[str, Any]) -> bool:
+    """Whether the stated posture follows from the two axes given.
+
+    Recomputed rather than trusted. The matrix and its thresholds are
+    `_pillars.py`'s, copied into the producer by value, and a copied
+    constant is a constant that can drift — so the one place the two
+    can be compared is here, against a document carrying both inputs
+    and the answer.
+    """
+    from ._pillars import posture as compute
+
+    stated = payload.get("posture")
+    practice = payload.get("practice")
+    if stated is None or not isinstance(practice, dict):
+        return True
+    level = practice.get("level")
+    condition = payload.get("condition")
+    if not isinstance(level, int):
+        return False
+    return compute(level, condition) == stated

{maintainability_agent-3.1.0 → maintainability_agent-3.3.0}/src/maintainability_audit/_derive.py

@@ -17,9 +17,10 @@ from statistics import median
 from typing import Any
 
 from ._aspects import evidence_aspect_scores, is_untested
+from ._evidence_reader import normalize_report_evidence
 from ._formula import CALIBRATED_ASPECTS, curve, overall_from_aspects
 from ._pressures import production_pressures
-from .evidence import REPORT_SCHEMA_VERSION, SCHEMA_VERSION_KEY, normalize_report_evidence
+from .evidence import REPORT_SCHEMA_VERSION, SCHEMA_VERSION_KEY
 
 # The stored column holding the analyzers' production reading. Named
 # once because both the refusal and the mix key on it.