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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maintainability-agent
-Version: 3.0.2
+Version: 3.1.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.0.2**.
+Version **3.1.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.0.2 → maintainability_agent-3.1.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.0.2**.
+Version **3.1.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.0.2 → maintainability_agent-3.1.0}/pyproject.toml

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maintainability-agent
-Version: 3.0.2
+Version: 3.1.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.0.2**.
+Version **3.1.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.0.2 → maintainability_agent-3.1.0}/src/maintainability_agent.egg-info/SOURCES.txt

@@ -183,6 +183,7 @@ tests/test_calibration_tooling.py
 tests/test_catalog_selection.py
 tests/test_catalog_tier_promise.py
 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_ci_history_recipe.py
@@ -337,10 +338,13 @@ tests/test_test_commands.py
 tests/test_test_execution_class.py
 tests/test_three_presentations.py
 tests/test_tool_resolution.py
+tests/test_tree_cannot_opt_the_host_in.py
 tests/test_tree_chosen_spawn.py
+tests/test_tree_reads_use_the_primitive.py
 tests/test_trends.py
 tests/test_type_fields_not_functions_class.py
 tests/test_uat_falsifiers.py
+tests/test_unanchored_set_matches_corpus.py
 tests/test_unread_code.py
 tests/test_user_config_tier.py
 tests/test_verification_audit_closures.py
@@ -348,6 +352,7 @@ tests/test_verified_grade.py
 tests/test_version_claim.py
 tests/test_wheel_contents.py
 tests/test_work_order.py
+tests/test_work_order_binds_to_this_interpreter.py
 tests/test_work_order_items.py
 tests/test_work_order_selection.py
 tests/test_workflow_supply_chain.py

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

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

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

@@ -25,12 +25,33 @@ 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", "Go", "Rust", "PHP", "Ruby")
+#: Stated rather than derived, and the reason still holds:
+#: `tools/calibration/corpus.json` is a repository file that does not ship
+#: in the wheel, so a runtime read would be unavailable exactly where a
+#: user reads a grade. What a stated list buys in availability it owes in
+#: upkeep, and it did not pay.
+#:
+#: **D143.** This read `("Swift", "COBOL", "Go", "Rust", "PHP", "Ruby")`
+#: after 3.0.0 anchored five of those six. The corpus grew from 112
+#: repositories to 180 and from eight measured languages to thirteen, and
+#: this line did not move — so every skin told a Swift, Go, Rust, PHP or
+#: Ruby reader their grade was provisional against a corpus that had
+#: measured their language for two releases. A caveat that names an
+#: anchored language is not a caution, it is a false statement about the
+#: evidence, and it undersells the thing the recalibration was for.
+#:
+#: COBOL stays, and stays alone. It is parsed and deliberately never
+#: anchored: GitHub holds one COBOL repository above 500 stars and what is
+#: there is curriculum, Java parsers and JavaScript wrappers rather than
+#: COBOL codebases, so the corpus policy excludes it permanently rather
+#: than temporarily. Emptying this tuple would delete a disclosure that is
+#: still true.
+#:
+#: `tests/test_unanchored_set_matches_corpus.py` recomputes
+#: `parsed - corpus` from `DECLARATION_SUFFIXES` and `corpus.json` and
+#: fails if this stops matching — including when a language is *added* to
+#: the corpus, which is the direction that went unnoticed.
+UNANCHORED_LANGUAGES: tuple[str, ...] = ("COBOL",)
 
 
 def unanchored_names() -> str:

{maintainability_agent-3.0.2 → maintainability_agent-3.1.0}/src/maintainability_audit/_assets/standard.md

@@ -118,10 +118,20 @@ The corpus median lands at **4.0 (B)**: a well-run real codebase earns a B, and
 
 ### The reference corpus
 
-Calibration is reproducible, not a snapshot someone took once. The corpus is defined in [`tools/calibration/corpus.json`](../tools/calibration/corpus.json) — 40 mature open-source repositories **pinned to exact commits**, spanning 32 to 18,789 source files and 463,581 declarations across Python, TypeScript and JavaScript:
+Calibration is reproducible, not a snapshot someone took once. The corpus is defined in [`tools/calibration/corpus.json`](../tools/calibration/corpus.json) — **180 mature open-source repositories pinned to exact commits**, spanning 24 to 18,789 source files and 2,749,575 declarations across thirteen languages: Python, TypeScript, JavaScript, Java, C, C++, C#, Fortran, Swift, Go, Rust, PHP and Ruby.
+
+The forty repositories 1.x calibrated on are all still in it, at the commits they were measured at then:
 
 > angular · ansible · ant-design · anime · axios · Chart.js · code-server · django · echarts · excalidraw · express · fastapi · flask · freeCodeCamp · github-readme-stats · hackingtool · hoppscotch · jquery · keras · localstack · lodash · manim · material-ui · mermaid · models · n8n · nest · playwright · reveal.js · scrapy · strapi · svelte · tabby · tailwindcss · transformers · uBlock · vite · webpack · youtube-dl · yt-dlp
 
+**This paragraph opened "40 mature open-source repositories … across
+Python, TypeScript and JavaScript" for two releases after 3.0.0 measured
+180 across thirteen (D143).** The corrected numbers were four paragraphs
+below it the whole time, so a reader met both and had nothing to tell
+them which was current. Same defect as the unanchored caveat below and
+found in the same pass: a count written into prose, with nothing that
+fails when the thing it counts moves.
+
 **What the anchor does not cover.** For five releases this section named a
 real defect: the corpus was 40 repositories of Python, TypeScript and
 JavaScript while the scanner parsed eight languages, so Java, C, C++, C#
@@ -131,23 +141,34 @@ median and fortran-lang/stdlib at **1.10x** — the first a true statement
 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 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.
-
-**Six parsed languages are not in it.** Swift (2.4.0), COBOL (2.7.0)
-and Go, Rust, PHP and Ruby (2.11.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.
+**3.0.0 extended the corpus.** It is now **180 repositories spanning
+thirteen languages**: Python, TypeScript, JavaScript, Java, C, C++, C#,
+Fortran, Swift, Go, Rust, PHP and Ruby. The 112 rows measured for 2.0.0
+are unchanged and still pinned to the commits they were measured at, so
+what moved the constants is the languages added and nothing else.
+
+**One parsed language is not in it: COBOL.** It is **unanchored** — a
+scanner reads it, and the medians its rates are compared against were
+measured on other languages. The cost is disclosed rather than absorbed:
+findings in COBOL are as good as their parser, a COBOL grade is
+provisional, and every surface that prints a grade says so.
+
+COBOL is unanchored **permanently**, not pending a re-measure. Against
+the corpus criteria GitHub holds one COBOL repository above 500 stars,
+and what is public is curriculum, Java parsers and JavaScript wrappers
+rather than COBOL codebases; the language's real corpus is on private
+mainframes. Anchoring it on what exists would build a reference out of
+teaching material — an anchor that *looks* like one, which is worse than
+the disclosed absence.
+
+Two corrections are recorded here rather than quietly applied, because
+both were live for multiple releases. This sentence read "every language
+this scanner parses" for three releases after that stopped being true.
+It then named **six** unanchored languages for two releases after 3.0.0
+anchored five of them (D143) — Swift, Go, Rust, PHP and Ruby readers were
+told their grade was provisional against a corpus that had measured their
+language. A caveat naming an anchored language is not a caution; it is a
+false statement about the evidence.
 
 Three limits remain, and they are narrower than the one they replace:
 

{maintainability_agent-3.0.2 → maintainability_agent-3.1.0}/src/maintainability_audit/_banner.py

@@ -17,9 +17,12 @@ one-way.
 """
 from __future__ import annotations
 
+import os
 import re
 from pathlib import Path
 
+from ._operator_reads import open_regular_file
+
 # Whatever a language uses to open a comment, plus decoration a generator
 # may pad the line with: `#`, `//`, `*`, `/*`, `!`, `--`, `<!--`, `;`, and
 # the emoji rules some tools draw. `@` is spared, or `# @generated` would
@@ -40,12 +43,29 @@ BANNER_LINES = 20
 def banner_says_generated(
     path: Path, banners: tuple[str, ...]
 ) -> str | None:
-    """The banner text, if the head of this file carries one."""
+    """The banner text, if the head of this file carries one.
+
+    The head only, so this stays cheap on a large tree — but read
+    *through* a checked handle rather than by name, so a FIFO refuses
+    instead of stopping the audit dead (D145). `path.open()` on one waits
+    for a writer that never comes, and the previous `except OSError`
+    could not have caught that: there is no error to catch, only a
+    process that never returns.
+    """
     try:
-        with path.open(encoding="utf-8", errors="replace") as handle:
-            head = "".join(next(handle, "") for _ in range(BANNER_LINES)).lower()
+        handle = open_regular_file(
+            path,
+            "Banner detection reads the head of a discovered file; a "
+            "device, socket or FIFO would block the audit rather than "
+            "declare itself generated.",
+        )
     except OSError:
         return None
+    try:
+        with os.fdopen(handle, "r", encoding="utf-8", errors="replace", closefd=False) as opened:
+            head = "".join(next(opened, "") for _ in range(BANNER_LINES)).lower()
+    finally:
+        os.close(handle)
     previous: str | None = None
     for raw in head.splitlines():
         stripped = COMMENT_LEAD.sub("", raw).strip()

{maintainability_agent-3.0.2 → maintainability_agent-3.1.0}/src/maintainability_audit/_discovery.py

@@ -42,6 +42,7 @@ from typing import Any
 
 from ._banner import banner_says_generated
 from ._metrics_types import KNOWN_SOURCE_SUFFIXES, is_test_path
+from ._operator_reads import PathNotAllowed, read_source_file
 from .metrics import is_excluded
 
 # The inventory names languages the way a person does; the analyzer
@@ -207,6 +208,19 @@ class Inventory:
         return tally
 
 
+def _text_of(path: Path) -> str:
+    """A repository file's text, read through the regular-file primitive.
+
+    Discovery reads whatever the tree names — `package.json` anywhere
+    beneath the root, `.gitmodules` at it — so every path here is
+    repository-controlled and none of it was going through the door
+    D131 and D141 built (D145). `read_text` on a FIFO waits for a writer
+    that never comes, and no `except OSError` catches a process that
+    simply does not return.
+    """
+    return "\n".join(read_source_file(path))
+
+
 def _generated_directories(root: Path, excludes: tuple[str, ...]) -> dict[str, str]:
     """Directories a `package.json` script deletes and rebuilds."""
     found: dict[str, str] = {}
@@ -215,7 +229,15 @@ def _generated_directories(root: Path, excludes: tuple[str, ...]) -> dict[str, s
         if is_excluded(relative, list(excludes)):
             continue
         try:
-            scripts = json.loads(manifest.read_text(encoding="utf-8")).get("scripts", {})
+            scripts = json.loads(_text_of(manifest)).get("scripts", {})
+        except PathNotAllowed:
+            # `PathNotAllowed` is a `ValueError`, so it would otherwise be
+            # swallowed by the clause below and the manifest would read as
+            # a malformed one rather than a refused one (D145). A FIFO
+            # named `package.json` is not bad JSON; it is a path this tool
+            # will not read, and saying so is the whole point of routing
+            # the read through the primitive.
+            raise
         except (OSError, ValueError, AttributeError):
             continue
         if not isinstance(scripts, dict):
@@ -241,7 +263,7 @@ def _vendored_directories(root: Path) -> dict[str, str]:
     modules = root / ".gitmodules"
     if modules.exists():
         try:
-            text = modules.read_text(encoding="utf-8", errors="replace")
+            text = _text_of(modules)
         except OSError:
             text = ""
         for entry in re.finditer(r"^\s*path\s*=\s*(.+?)\s*$", text, re.MULTILINE):

{maintainability_agent-3.0.2 → maintainability_agent-3.1.0}/src/maintainability_audit/_environment.py

@@ -13,6 +13,8 @@ holds that structurally.
 """
 from __future__ import annotations
 
+import shlex
+import sys
 from typing import Any
 
 # Outcomes a user can act on. `timed-out` and `failed` are excluded on
@@ -53,6 +55,57 @@ _VERIFY: dict[str, str] = {
 }
 
 
+def _remedy_for(slug: str) -> dict[str, str]:
+    """The install and verify commands, bound to the interpreter that audits.
+
+    A remedy is only a remedy if it addresses the same environment the
+    next audit reads. `pip install lizard` and `lizard --version` name
+    neither: they address whatever `pip` and `lizard` `PATH` happens to
+    resolve, which on any machine with more than one Python is a
+    different interpreter than the one that just reported the tool
+    missing (D144).
+
+    That is not hypothetical here. D142 was the same gap seen from the
+    other side — the agent could not find tools the operator had already
+    installed, because `pip` had put them where `PATH` did not look. A
+    work order that hands back a bare `pip` sends the operator around
+    that loop again, and the second time it looks like the remedy simply
+    does not work.
+
+    So pip-backed adapters emit `{sys.executable} -m pip ...`. The dict
+    entries stay spelled as distribution names — `pip install
+    fortitude-lint` — because two tests derive the CI install list from
+    them, and rewriting the dict would move a fact that belongs at the
+    emit site into the data.
+
+    Verification moves from `--version` to `pip show` for these, and the
+    reason is worth stating because the old comment argued the opposite:
+    `--version` was chosen to run the same probe the runner runs. Since
+    D142 the runner does not probe `PATH` at all — it searches this
+    interpreter's script directories — so a bare `{slug} --version`
+    verifies a *different* thing than the audit does. `pip show` asks the
+    question that actually decides the next run: is this distribution
+    installed for this interpreter.
+
+    Node and JVM overrides are untouched. `npx` and `brew` are not
+    interpreter-scoped and rewriting them through `sys.executable` would
+    name a Python package that does not exist.
+    """
+    install = _INSTALL.get(slug, f"pip install {slug}")
+    if not install.startswith("pip install"):
+        return {"install": install, "verify": _VERIFY.get(slug, f"{slug} --version")}
+    distribution = install.split()[-1]
+    return {
+        "install": _pip_command("install", distribution),
+        "verify": _pip_command("show", distribution),
+    }
+
+
+def _pip_command(action: str, distribution: str) -> str:
+    """A pip invocation that cannot resolve to another interpreter."""
+    return f"{shlex.quote(sys.executable)} -m pip {action} {distribution}"
+
+
 def environment_work_order(coverage: list[Any]) -> list[dict[str, str]]:
     """One item per selected analyzer that could not contribute.
 
@@ -82,8 +135,7 @@ def environment_work_order(coverage: list[Any]) -> list[dict[str, str]]:
         items.append({
             "tool": entry.slug,
             "reason": entry.detail or f"outcome: {entry.outcome}",
-            "install": _INSTALL.get(entry.slug, f"pip install {entry.slug}"),
-            "verify": _VERIFY.get(entry.slug, f"{entry.slug} --version"),
+            **_remedy_for(entry.slug),
             # What installing the tool restores, so a host can explain
             # the trade instead of relaying a bare command (D9).
             "concepts": ", ".join(entry.concepts),

{maintainability_agent-3.0.2 → maintainability_agent-3.1.0}/src/maintainability_audit/_in_loop.py

@@ -299,6 +299,52 @@ def _is_unified_diff(text: str) -> bool:
     return has_hunk or (has_old and has_new)
 
 
+#: The two marks a unified diff puts in column one on a changed line.
+#: Context lines carry a space, which is why a fragment of *context*
+#: still parses: it is the file's own text with one column of padding,
+#: and refusing it would refuse the ordinary case of a pasted excerpt.
+_CHANGE_MARKS = ("+", "-")
+
+
+def _is_diff_fragment(text: str) -> bool:
+    """Whether this is the changed lines of a diff with the frame cut off.
+
+    D138 loosened `_is_unified_diff` so a hunk-only paste is refused,
+    because a chat window shows the hunk and not the file headers. This
+    is the paste one step smaller again, and the commonest of all: an
+    agent copies the *green* lines out of a review pane and pipes them
+    to `--check`. There is no `@@` and there are no `---`/`+++`
+    headers, so every shape check above passes it through, the brace
+    scanners find nothing in `+function hello() {`, and
+    `declarations_read` reports true (D146).
+
+    That is the same absence-read-as-a-pass D133 and D138 each closed
+    one fragment shape to the left, and the third time it arrived the
+    detector was still being widened by example rather than by rule. So
+    the rule is stated here: a body whose every non-blank line begins
+    with a change mark is a diff fragment, whatever suffix it was
+    named. Nothing else in this project's fourteen languages is written
+    that way, and a file that genuinely is would still be measured as
+    zero declarations rather than silently reported as read.
+
+    **The mention-versus-assertion guard survives, and by construction
+    rather than by luck.** Somebody writing *about* a diff writes prose
+    or code around the quoted line — `text = '+function hello()'` — and
+    that surrounding line does not begin with a mark, so the body is not
+    all-marked and parses normally. The guard is the same one
+    `_HUNK_HEADER`'s anchored `match` gives the hunk check: a mark has
+    to hold column one of *every* line to count, and a mention never
+    does.
+
+    Blank lines are ignored rather than counted against the fragment,
+    because a copied hunk keeps its blank lines unmarked.
+    """
+    marked = [line for line in text.splitlines() if line.strip()]
+    if not marked:
+        return False
+    return all(line[0] in _CHANGE_MARKS for line in marked)
+
+
 def _parses(path: str, text: str) -> bool:
     """Whether the content is what its extension claims to be.
 
@@ -309,7 +355,7 @@ def _parses(path: str, text: str) -> bool:
     is absence read as a pass, arriving through the exact feature whose
     docstring promises to refuse it (Gemini's field check).
     """
-    if _is_unified_diff(text):
+    if _is_unified_diff(text) or _is_diff_fragment(text):
         return False
     if Path(path).suffix != ".py":
         # No parser for the brace languages, and zero declarations is not

{maintainability_agent-3.0.2 → maintainability_agent-3.1.0}/src/maintainability_audit/_practice.py

@@ -31,11 +31,13 @@ engineering practice made from the outside.
 
 from __future__ import annotations
 
+import os
 import re
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
 
+from ._operator_reads import open_regular_file
 from .metrics import is_excluded
 
 # A repository holding config but running none of it. See the module
@@ -139,10 +141,32 @@ class Practice:
 
 
 def _read(path: Path, limit: int = 200_000) -> str:
+    """A bounded read of a repository file, through a checked handle.
+
+    The head only, so this stays cheap on a large tree — but read
+    *through* a checked handle rather than by name, so a FIFO refuses
+    instead of stopping the audit dead (D145). `path.open()` on one waits
+    for a writer that never comes, and the previous `except OSError`
+    could not have caught that: there is no error to catch, only a
+    process that never returns.
+
+    Practice detection reads whatever the tree names as CI and toolchain
+    configuration, so every path here is repository-controlled.
+    """
     try:
-        return path.read_text(encoding="utf-8", errors="replace")[:limit]
+        handle = open_regular_file(
+            path,
+            "Practice detection reads CI and toolchain files from the "
+            "audited tree; a device, socket or FIFO would block the audit "
+            "rather than describe a practice.",
+        )
     except OSError:
         return ""
+    try:
+        with os.fdopen(handle, "r", encoding="utf-8", errors="replace", closefd=False) as opened:
+            return opened.read(limit)
+    finally:
+        os.close(handle)
 
 
 def _ci_files(root: Path) -> list[Path]:

{maintainability_agent-3.0.2 → maintainability_agent-3.1.0}/src/maintainability_audit/_semantic_ts.py

@@ -20,6 +20,7 @@ import re
 from pathlib import Path
 from typing import Any
 
+from ._operator_reads import read_source_file
 from ._runner import Invocation, locate, run
 from .metrics import within
 
@@ -49,12 +50,21 @@ _QUOTED = re.compile(r"\"([A-Za-z_][\w-]*)\"")
 
 
 def recorded_type_analysis(root: Path) -> dict[str, Any] | None:
-    """The checked-in recording, when the repository keeps one."""
+    """The checked-in recording, when the repository keeps one.
+
+    `is_file()` used to stand in for both questions — does it exist, and
+    is it readable — and answered a FIFO with "absent" (D145). A
+    repository could then name `RECORDED_ANALYSIS` as a pipe and have
+    the tool report no recording rather than refuse one, which is the
+    same skip-and-pretend-absent shape D141 closed in the scan walk.
+    Existence is asked here; kind is asked by the primitive, which
+    refuses rather than waiting for a writer.
+    """
     path = root / RECORDED_ANALYSIS
-    if not path.is_file():
+    if not path.exists():
         return None
     try:
-        payload = json.loads(path.read_text(encoding="utf-8"))
+        payload = json.loads("\n".join(read_source_file(path)))
     except ValueError:
         return None
     return payload if isinstance(payload, dict) and payload.get("tool") else None
@@ -226,7 +236,7 @@ def operation_sets(root: Path) -> list[dict[str, Any]]:
     """
     found: list[dict[str, Any]] = []
     for path in _typescript_sources(root):
-        text = path.read_text(encoding="utf-8", errors="replace")
+        text = "\n".join(read_source_file(path))
         dispatch = frozenset(
             name for pair in _DISPATCH.findall(text) for name in pair if name
         )

{maintainability_agent-3.0.2 → maintainability_agent-3.1.0}/src/maintainability_audit/_setup_persist.py

@@ -12,7 +12,7 @@ from typing import Any
 
 from ._safe_write import write_bounded
 from ._setup_errors import SetupRequired
-from ._user_config import write_user_answers
+from ._user_config import user_config_answers, write_user_answers
 from .config import CONFIG_FILENAME, discovered_config, load_config
 from .config import _configured as _read_config
 
@@ -75,6 +75,33 @@ def _is_bounds_only(answers: dict[str, Any]) -> bool:
     return bool(given) and given <= names
 
 
+def _user_tier_with(**changes: Any) -> dict[str, Any]:
+    """The user's stored answers plus these, and nothing from the tree.
+
+    Both staged writers used to hand `write_user_answers` the
+    **repository's** document, because that was the dict they had built
+    for the repository write and it looked like "the config". So a
+    two-stage setup — answer the rates, or the test command — copied
+    whatever the audited tree had written under `analyzers.acquire_tools`,
+    `test_execution.requested` and `expected_commands.test` straight into
+    the user tier, which is the one tier `acquisition_permitted` and
+    `opted_in_command` trust (D147).
+
+    Four lines in a pull request, then any staged reply, and the tree had
+    granted itself `npx --yes` and a command to run. Neither check was
+    wrong: the tier they read had been told the tree's answers were the
+    user's.
+
+    So the user tier is now built **from the user tier**, the way
+    `_persist_answers` builds it from the setup payload. Merged rather
+    than replaced, for the same reason `_persist_answers` merges: a
+    stage-two reply must not reset the answers stage one wrote (D13).
+    """
+    stored = dict(user_config_answers() or {})
+    stored.update(changes)
+    return stored
+
+
 def _apply_bounds(root: Path, answers: dict[str, Any]) -> dict[str, Any]:
     """Fill the rates into a configuration that already has its answers.
 
@@ -91,7 +118,7 @@ def _apply_bounds(root: Path, answers: dict[str, Any]) -> dict[str, Any]:
         Path(root), config_path,
         json.dumps(stored, indent=2, sort_keys=True) + "\n",
     )
-    write_user_answers(stored)
+    write_user_answers(_user_tier_with(economic_context=economics))
     return load_config(str(config_path))
 
 
@@ -114,14 +141,31 @@ def _apply_command(root: Path, answers: dict[str, Any]) -> dict[str, Any]:
         commands = dict(stored.get("expected_commands") or {})
         commands["test"] = shlex.split(command)
         stored["expected_commands"] = commands
+        # The user tier carries the command as well as the request,
+        # because `opted_in_command` reads both from there: a person
+        # consents to the command they were shown, and leaving the
+        # command to the repository would keep the consent and hand back
+        # the choice of what it means (D147).
+        user_tier = _user_tier_with(
+            expected_commands={
+                **(user_config_answers() or {}).get("expected_commands", {}),
+                "test": shlex.split(command),
+            },
+        )
     else:
         stored["test_execution"] = {"requested": False}
+        user_tier = _user_tier_with(
+            test_execution={
+                **(user_config_answers() or {}).get("test_execution", {}),
+                "requested": False,
+            },
+        )
     config_path = Path(root) / CONFIG_FILENAME
     write_bounded(
         Path(root), config_path,
         json.dumps(stored, indent=2, sort_keys=True) + "\n",
     )
-    write_user_answers(stored)
+    write_user_answers(user_tier)
     return load_config(str(config_path))