maintainability-agent 3.6.2__tar.gz → 3.7.0__tar.gz

{maintainability_agent-3.6.2/src/maintainability_agent.egg-info → maintainability_agent-3.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maintainability-agent
-Version: 3.6.2
+Version: 3.7.0
 Summary: Maintainability gate and AI remediation prompt generator for CI.
 Author: Marshall Guillory
 License: MIT
@@ -19,6 +19,7 @@ Classifier: Topic :: Software Development :: Quality Assurance
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: secure-code-agent<0.11,>=0.10
 Provides-Extra: test
 Requires-Dist: pytest>=8; extra == "test"
 Requires-Dist: pytest-cov>=5; extra == "test"
@@ -46,7 +47,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.6.2**.
+Version **3.7.0**.
 
 **Languages parsed:** Python, Java, C, C++, C#, Go, Rust, PHP, Ruby, Swift,
 COBOL, Fortran (free-form *and* fixed-form), and the JS/TS/HTML family — each

{maintainability_agent-3.6.2 → maintainability_agent-3.7.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.6.2**.
+Version **3.7.0**.
 
 **Languages parsed:** Python, Java, C, C++, C#, Go, Rust, PHP, Ruby, Swift,
 COBOL, Fortran (free-form *and* fixed-form), and the JS/TS/HTML family — each

{maintainability_agent-3.6.2 → maintainability_agent-3.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "maintainability-agent"
-version = "3.6.2"
+version = "3.7.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
@@ -13,6 +13,14 @@ readme = "README.md"
 # metadata said a user could stand: the suite runs 3.12 and the
 # composite action pins 3.11 (D42).
 requires-python = ">=3.11"
+# The security pillar is complete (D177): every audit runs secure-code-agent,
+# so it installs with this package rather than being left to the operator.
+# Its own dependency is PyYAML; this package still imports no YAML
+# (`test_the_shipped_package_does_not_import_yaml`) — it runs the tool as a
+# child and reads the JSON document it writes.
+dependencies = [
+  "secure-code-agent>=0.10,<0.11",
+]
 license = { text = "MIT" }
 authors = [
   { name = "Marshall Guillory" }

{maintainability_agent-3.6.2 → maintainability_agent-3.7.0/src/maintainability_agent.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maintainability-agent
-Version: 3.6.2
+Version: 3.7.0
 Summary: Maintainability gate and AI remediation prompt generator for CI.
 Author: Marshall Guillory
 License: MIT
@@ -19,6 +19,7 @@ Classifier: Topic :: Software Development :: Quality Assurance
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: secure-code-agent<0.11,>=0.10
 Provides-Extra: test
 Requires-Dist: pytest>=8; extra == "test"
 Requires-Dist: pytest-cov>=5; extra == "test"
@@ -46,7 +47,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.6.2**.
+Version **3.7.0**.
 
 **Languages parsed:** Python, Java, C, C++, C#, Go, Rust, PHP, Ruby, Swift,
 COBOL, Fortran (free-form *and* fixed-form), and the JS/TS/HTML family — each

{maintainability_agent-3.6.2 → maintainability_agent-3.7.0}/src/maintainability_agent.egg-info/SOURCES.txt

@@ -94,6 +94,7 @@ src/maintainability_audit/_safe_write.py
 src/maintainability_audit/_scan_history.py
 src/maintainability_audit/_scan_view.py
 src/maintainability_audit/_second_source.py
+src/maintainability_audit/_security_delegate.py
 src/maintainability_audit/_selection.py
 src/maintainability_audit/_semantic.py
 src/maintainability_audit/_semantic_policy.py
@@ -182,6 +183,7 @@ tests/test_band_concealment_p3.py
 tests/test_band_pressures.py
 tests/test_bands.py
 tests/test_body_or_signature_class.py
+tests/test_build_output_is_not_the_repositorys_code.py
 tests/test_c_declarations.py
 tests/test_calibration_corpus.py
 tests/test_calibration_drift.py
@@ -339,6 +341,7 @@ tests/test_scanning.py
 tests/test_schema_fidelity.py
 tests/test_scope_conformance.py
 tests/test_scoring_calibration.py
+tests/test_security_pillar_runs_and_shows.py
 tests/test_semantic_policy.py
 tests/test_setup_gate_completeness.py
 tests/test_setup_gate_independent_contract.py

{maintainability_agent-3.6.2 → maintainability_agent-3.7.0}/src/maintainability_agent.egg-info/requires.txt

@@ -1,3 +1,4 @@
+secure-code-agent<0.11,>=0.10
 
 [dev]
 pytest>=8

{maintainability_agent-3.6.2 → maintainability_agent-3.7.0}/src/maintainability_audit/__init__.py

@@ -1,3 +1,3 @@
 """Maintainability Audit CI."""
 
-__version__ = "3.6.2"
+__version__ = "3.7.0"

{maintainability_agent-3.6.2 → maintainability_agent-3.7.0}/src/maintainability_audit/_delegated_pillar.py

@@ -123,6 +123,25 @@ def read_delegated(root: Path, relative: str = DEFAULT_PILLAR_PATH) -> dict[str,
         if isinstance(error, PathNotAllowed):
             raise
         return None
+    return trusted(payload)
+
+
+def read_produced(path: Path) -> dict[str, Any] | None:
+    """The document this tool's own run of secure-code-agent just wrote (D177).
+
+    The file sits in a temporary directory this process created, not in the
+    audited tree, so it is read directly; every check a handed-over document
+    passes still applies, because the producer is the same tool either way.
+    """
+    try:
+        payload = json.loads(Path(path).read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    return trusted(payload)
+
+
+def trusted(payload: Any) -> dict[str, Any] | None:
+    """The payload when it is a document this module understands, else `None`."""
     if not isinstance(payload, dict):
         return None
     if payload.get("schema") != SCHEMA:

{maintainability_agent-3.6.2 → maintainability_agent-3.7.0}/src/maintainability_audit/_discovery.py

@@ -222,8 +222,31 @@ def _text_of(path: Path) -> str:
     return "\n".join(read_source_file(path))
 
 
+#: The evidence recorded for a path the repository ignores and git does not
+#: track (D175), so a reader can see why it left the scored population.
+IGNORED_BUILD_OUTPUT_EVIDENCE = (
+    "untracked, and excluded by this repository's .gitignore "
+    "(git ls-files --others --ignored)"
+)
+
+
+def _ignored_build_output(root: Path) -> dict[str, str]:
+    """Untracked paths the repository's `.gitignore` excludes (D175).
+
+    A Maven build copied jsoup's test resources into `target/test-classes`,
+    and the next audit scored 29 more files — one a failing file — as the
+    team's own. The same commit scored one way before a build and another
+    after it. `target/` is not added to a list of names: ADR 010 §1 forbids
+    that, and the next build tool will choose another word. The repository
+    already says which paths are not its source.
+    """
+    from .git_tools import ignored_untracked_paths
+
+    return dict.fromkeys(ignored_untracked_paths(root), IGNORED_BUILD_OUTPUT_EVIDENCE)
+
+
 def _generated_directories(root: Path, excludes: tuple[str, ...]) -> dict[str, str]:
-    """Directories a `package.json` script deletes and rebuilds."""
+    """Directories a `package.json` script deletes and rebuilds, then ignored build output."""
     found: dict[str, str] = {}
     for manifest in root.rglob("package.json"):
         relative = manifest.relative_to(root).as_posix()
@@ -237,6 +260,10 @@ def _generated_directories(root: Path, excludes: tuple[str, ...]) -> dict[str, s
                     f"deleted and rebuilt by `{name}` in {relative}: "
                     f"`{str(command)[:60]}`",
                 )
+    # A manifest's own statement about a directory is the more specific
+    # evidence, so it wins where both apply.
+    for path, evidence in _ignored_build_output(root).items():
+        found.setdefault(path, evidence)
     return found
 
 
@@ -458,10 +485,18 @@ def discover(root: Path, config: dict[str, Any]) -> Inventory:
     inventory.directories = _directory_provenance(
         vendored_dirs, generated_dirs, asset_dirs)
     seen_directories: set[tuple[str, str]] = set()
+    # What the scanner reads, beyond source code: a generated or vendored
+    # tree's HTML, XML and JSON are scored too unless classified here (D175).
+    read = set((config.get("paths") or {}).get("include_extensions", ()))
+    not_ours_dirs = (*generated_dirs, *vendored_dirs)
     for path in sorted(root.rglob("*")):
-        if not path.is_file() or path.suffix not in KNOWN_SOURCE_SUFFIXES:
+        if not path.is_file():
             continue
         relative = path.relative_to(root).as_posix()
+        if path.suffix not in KNOWN_SOURCE_SUFFIXES and not (
+            path.suffix in read and any(_under(relative, owner) for owner in not_ours_dirs)
+        ):
+            continue
         if is_excluded(relative, list(excludes)):
             continue
         verdict, evidence, owner = _classify(

{maintainability_agent-3.6.2 → maintainability_agent-3.7.0}/src/maintainability_audit/_pillars.py

@@ -87,8 +87,9 @@ PILLARS: tuple[Pillar, ...] = (
         name="security",
         scope=Scope.DELEGATED,
         reason=(
-            "delegated to secure-code-agent; this tool catalogues security "
-            "analyzers and never runs them, so silence here is not safety"
+            "delegated to secure-code-agent, which this audit runs for the pillar; "
+            "when no measurement comes back the reason is given here, because "
+            "silence is not safety"
         ),
     ),
     Pillar(
@@ -213,9 +214,14 @@ def pillar_report(
     score: dict[str, Any],
     practice: dict[str, Any],
     delegated: dict[str, dict[str, Any]] | None = None,
+    unmeasured: dict[str, str] | None = None,
 ) -> list[dict[str, Any]]:
     """The pillar block exactly as it ships.
 
+    `unmeasured` names, per delegated pillar, why no measurement came back
+    from a run of the tool that owns it (D177), and replaces the generic
+    reason so the reader learns what actually happened.
+
     Practice arrives as an argument rather than being computed here.
     `_practice` reads the repository's configuration off disk, which
     makes it a scanner, and the scoring layer may not reach upward into
@@ -251,7 +257,7 @@ def pillar_report(
         report.append({
             "pillar": pillar.name,
             "scope": pillar.scope.value,
-            "reason": pillar.reason,
+            "reason": (unmeasured or {}).get(pillar.name) or pillar.reason,
             # Both axes, side by side, never merged. A consumer reads
             # either one; nothing in the document offers their mean.
             "practice": resolved["level"],

{maintainability_agent-3.6.2 → maintainability_agent-3.7.0}/src/maintainability_audit/_prompt_sections.py

@@ -118,6 +118,30 @@ def prompt_analyzer_caveat(report: dict[str, Any]) -> list[str]:
     ]
 
 
+def prompt_security_pillar(report: dict[str, Any]) -> list[str]:
+    """What the security pillar reported, stated where an agent reads the run (D176).
+
+    Evidence, never a task: security remediation is secure-code-agent's own
+    work order, not this prompt's. But a prompt that says nothing about
+    security lets an agent read silence as a clean bill, which is the one
+    reading ADR 007 exists to prevent.
+    """
+    entry = next((p for p in report.get("pillars") or [] if p.get("pillar") == "security"), None)
+    if entry is None:
+        return []
+    if not entry.get("delegated_to"):
+        return [f"**Security pillar: not measured.** {entry.get('reason')}.", ""]
+    producer = entry.get("delegated_to") or "the delegated tool"
+    version = f" {entry['producer_version']}" if entry.get("producer_version") else ""
+    condition = "not graded" if entry.get("condition") is None else f"{entry['condition']:.1f}"
+    return [
+        f"**Security pillar (measured by {producer}{version}):** posture "
+        f"{entry.get('posture')}, practice level {entry.get('practice')}, condition "
+        f"{condition}. Its findings are that tool's work order, not this one.",
+        "",
+    ]
+
+
 def prompt_escalation_note(report: dict[str, Any]) -> list[str]:
     """Tell the agent what is deliberately absent, and why.
 

{maintainability_agent-3.6.2 → maintainability_agent-3.7.0}/src/maintainability_audit/_scan_view.py

@@ -364,6 +364,13 @@ def pillar_cells(entry: dict[str, Any]) -> tuple[str, str]:
     condition = "—" if entry["condition"] is None else f"{entry['condition']:.1f}"
     if entry["posture"] is None:
         return condition, "not measured — see below"
+    if entry["condition"] is None:
+        # An ungraded pillar is `unverified` because nothing could be graded,
+        # not because a clean scan lacks enforcement — the note for that cell
+        # told a reader of secure-code-agent's partial-coverage pillar that
+        # its scan was clean (D176). Say why no grade was issued instead.
+        why = (entry.get("evidence_reasons") or [None])[0] or "the evidence could not support a grade"
+        return condition, f"{entry['posture']}: not graded — {why}"
     note = POSTURE_NOTE.get(entry["posture"], entry["posture"])
     return condition, f"{entry['posture']}: {note}"
 

maintainability_agent-3.7.0/src/maintainability_audit/_security_delegate.py

@@ -0,0 +1,121 @@
+"""This tool runs secure-code-agent for the security pillar (D177).
+
+[ADR 007](adr-007-pillars-and-practice.md) delegates the security pillar to
+`secure-code-agent`. Until 3.7.0 the delegation was a handoff: the other
+tool wrote `security-pillar.json` and this one read it if it happened to be
+there. Nothing ran it, so every audit that did not follow a manual or CI run
+of the other tool reported the pillar as unmeasured — including every audit
+through the chat door, which cannot run it at all. Decided 2026-09-13 with
+Marshall: the pillar is complete, so the audit runs it.
+
+**What the child writes.** Every report `secure-code-agent` can produce is
+redirected into a temporary directory this process owns: the Markdown and
+JSON reports, SARIF, the PR comment, the remediation prompt and the pillar
+document itself. The one write that cannot be redirected is its append-only
+trend, `.secure-code/history.jsonl` in the audited tree, which it writes on
+every run from its own configuration. Turning that off would mean handing
+it a configuration from outside the tree, and `secure-code-agent` trusts an
+outside configuration to name executables in the tree — so the override
+would launder repository content past the other tool's own boundary. The
+history is therefore declared, not suppressed.
+
+**How the child is started.** Through `_runner.run`, like every analyzer and
+the opted-in test command, so architecture rule 7 still holds: the tree can
+reach one execution path, not a new one per feature. The command is the
+interpreter doing the auditing, the way D144 and D166 bound theirs, so the
+pillar is measured by the `secure-code-agent` installed beside this package
+rather than whichever one `PATH` finds. It gets the runner's stripped
+environment and a neutral working directory: not a sandbox, and not claimed
+as one.
+
+A run that produces no trustworthy document says why. Absence is never
+silent, because silence is exactly what ADR 007 says must not read as safety.
+"""
+from __future__ import annotations
+
+import importlib.util
+import shlex
+import sys
+import tempfile
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from ._delegated_pillar import read_produced
+from ._runner import Invocation, Outcome, run
+
+#: The distribution the pillar requires, and the range this tool reads.
+REQUIREMENT = "secure-code-agent>=0.10,<0.11"
+
+#: How long the child may run before the pillar is reported as unmeasured.
+DEFAULT_TIMEOUT_SECONDS = 300
+
+_ENTRY = "import sys; from secure_code_audit.cli import main; sys.exit(main())"
+
+
+@dataclass(frozen=True)
+class DelegateRun:
+    """What one run of the delegate produced, and why when it produced nothing."""
+
+    document: dict[str, Any] | None
+    reason: str | None = None
+    environment: list[dict[str, str]] = field(default_factory=list)
+
+
+def _install_remedy(reason: str) -> dict[str, str]:
+    """An environment work-order entry, bound to the auditing interpreter (D144)."""
+    python = shlex.quote(sys.executable)
+    return {
+        "tool": "secure-code-agent",
+        "reason": reason,
+        "install": f"{python} -m pip install '{REQUIREMENT}'",
+        "verify": f"{python} -m pip show secure-code-agent",
+        "concepts": "security",
+    }
+
+
+def run_security_delegate(
+    root: Path, *, changed_revspec: str | None = None,
+    timeout_seconds: int = DEFAULT_TIMEOUT_SECONDS,
+) -> DelegateRun:
+    """Run `secure-code-agent` over `root` and return its pillar document."""
+    if importlib.util.find_spec("secure_code_audit") is None:
+        reason = "secure-code-agent is not installed for the interpreter running this audit"
+        return DelegateRun(None, reason, [_install_remedy(reason)])
+    with tempfile.TemporaryDirectory(prefix="ma-security-") as scratch:
+        out = Path(scratch)
+        pillar = out / "security-pillar.json"
+        argv = [
+            sys.executable, "-c", _ENTRY, str(root),
+            "--security-pillar", str(pillar),
+            "--output", str(out / "report.md"),
+            "--json-output", str(out / "report.json"),
+            "--sarif-output", str(out / "report.sarif"),
+            "--comment-output", str(out / "comment.md"),
+            "--prompt-output", str(out / "prompt.md"),
+        ]
+        if changed_revspec:
+            argv += ["--changed-only", changed_revspec]
+        # Exit 1 is the tool's gate verdict, not a failure to measure: the
+        # pillar document is still written, and the pillar reports the gate.
+        result = run("secure-code-agent", Invocation(
+            argv=tuple(argv), findings_exit_codes=(0, 1), cwd=out,
+        ), timeout_seconds=timeout_seconds)
+        document = read_produced(pillar)
+        if document is not None:
+            return DelegateRun(document)
+        if result.outcome is Outcome.TIMED_OUT:
+            return DelegateRun(None, f"secure-code-agent did not finish within {timeout_seconds}s")
+        detail = _last_line(result.stderr) or _last_line(result.stdout) or result.detail
+        # No install remedy here: the tool is installed and ran. A rejected
+        # configuration or a crash is fixed in the repository or reported
+        # upstream, and an install command would send the reader to the
+        # wrong place.
+        reason = (f"secure-code-agent exited {result.exit_code} without a pillar document"
+                  + (f": {detail}" if detail else ""))
+        return DelegateRun(None, reason)
+
+
+def _last_line(text: str | None) -> str:
+    lines = [line.strip() for line in (text or "").splitlines() if line.strip()]
+    return lines[-1][:200] if lines else ""

{maintainability_agent-3.6.2 → maintainability_agent-3.7.0}/src/maintainability_audit/config.py

@@ -20,7 +20,7 @@ from ._operator_reads import (
 # still the door every caller comes through.
 __all__ = ["DEFAULT_CONFIG", "DEFAULT_IDIOM_GROUPS", "PROJECT_URL", "VERSION"]
 
-VERSION = "3.6.2"
+VERSION = "3.7.0"
 
 PROJECT_URL = "https://github.com/marshallguillory86/maintainability-agent"
 

{maintainability_agent-3.6.2 → maintainability_agent-3.7.0}/src/maintainability_audit/git_tools.py

@@ -231,6 +231,36 @@ def probe_git(args: list[str], cwd: Path) -> str:
         return ""
 
 
+def ignored_untracked_paths(root: Path) -> set[str]:
+    """Paths the repository's own `.gitignore` files exclude and git does not track (D175).
+
+    A build writes `target/`, `out/` or `bin/` into the working tree, and the
+    repository's `.gitignore` is where it says those are not its source.
+    That is evidence the repository provides, so ADR 010 can act on it where
+    a list of directory names cannot.
+
+    Only the per-directory `.gitignore` files are read. `--exclude-standard`
+    would also honour `.git/info/exclude` and the user's `core.excludesFile`,
+    which differ by machine — the same commit would then score differently
+    on two laptops (P1). A tracked file matched by an ignore rule is not
+    listed, because git tracks it, and an untracked file that is *not*
+    ignored stays in: that is uncommitted work, which D56 keeps visible.
+
+    Directories come back with a trailing slash, which is stripped. A tree
+    git cannot read — not a repository, git absent — yields nothing, which
+    is the absence of evidence rather than a verdict.
+    """
+    try:
+        output = run_git(
+            ["ls-files", "--others", "--ignored",
+             "--exclude-per-directory=.gitignore", "--directory", "-z"],
+            root, strip=False,
+        )
+    except GitCommandFailed:
+        return set()
+    return {entry.rstrip("/") for entry in output.split("\0") if entry.strip("/")}
+
+
 def changed_paths(root: Path, revspec: str) -> set[str]:
     """Paths touched by `revspec`, as forward-slash relative strings.
 

{maintainability_agent-3.6.2 → maintainability_agent-3.7.0}/src/maintainability_audit/mcp_server.py

@@ -4,10 +4,12 @@ This module is transport assembly: tool bindings, resources, prompts and
 the stdio entry point. The audit tool's own logic — authorization,
 tri-state resolution, history recording — lives in ``_mcp_audit`` and is
 re-exported here so every consumer keeps one import path. Setup, the
-loop record and baseline adoption may write only five local artifacts:
+loop record and baseline adoption may write only six local artifacts:
 repository and user configuration, user state, the repository's scan
-history, and the repository's baseline. It never writes source or a
-report, accepts a command string, or invokes a shell.
+history, the repository's baseline, and — because an audit runs
+secure-code-agent for the security pillar (D177) — that tool's own
+append-only trend. It never writes source or a report, accepts a command
+string, or invokes a shell.
 """
 
 from __future__ import annotations
@@ -66,11 +68,13 @@ SERVER_INSTRUCTIONS = (
     "step: do not inspect configuration first and do not ask the user "
     "which config to use — the tool resolves that itself. First contact with an "
     "unconfigured repository elicits setup, and the audit records its scan "
-    "history and can adopt a baseline, so it may write exactly five local "
+    "history and can adopt a baseline, so it may write exactly six local "
     "artifacts: the repository's maintainability-agent.json, the user-level "
     "config, the user state file, the repository's scan history "
-    "(.maintainability/history.jsonl by default), and a requested baseline "
-    "(.maintainability/baseline.json by default). Scan history rides the "
+    "(.maintainability/history.jsonl by default), a requested baseline "
+    "(.maintainability/baseline.json by default), and secure-code-agent's own "
+    "trend (.secure-code/history.jsonl), which that tool appends when the audit "
+    "runs it for the security pillar. Scan history rides the "
     "record_history tri-state, where unset means an existing history file "
     "appends and otherwise the persisted first-run consent decides, "
     "true forces the write, and false suppresses it. Nothing is audited "
@@ -109,12 +113,14 @@ def server_info(roots: tuple[Path, ...] | None = None) -> dict[str, Any]:
         "transport": "stdio",
         "local": True,
         # Not blanket read-only since D2/D5: setup, the loop record and
-        # baseline adoption write exactly the five local artifacts
-        # listed below, never source and never a report.
+        # baseline adoption write the local artifacts listed below, and the
+        # security pillar's run of secure-code-agent appends that tool's own
+        # trend (D177). Never source and never a report.
         "read_only": False,
         "writes": [CONFIG_FILENAME, "user config", "user state",
                    f"scan history ({DEFAULT_HISTORY_PATH})",
-                   "baseline (.maintainability/baseline.json)"],
+                   "baseline (.maintainability/baseline.json)",
+                   "secure-code-agent history (.secure-code/history.jsonl)"],
         "never_writes": ["source", "reports"],
         "allowed_roots": [str(root) for root in authorized_roots],
         # Stored grants this process will not honour. A hand-written

{maintainability_agent-3.6.2 → maintainability_agent-3.7.0}/src/maintainability_audit/prompts.py

@@ -69,6 +69,7 @@ def render_ai_prompt(report: dict[str, Any]) -> str:
         "",
     ])
     lines.extend(prompt_analyzer_caveat(report))
+    lines.extend(prompt_security_pillar(report))
     # The prompt is the product artifact (H1): its remedy follows the
     # same report fact as every other skin, never a stale default.
     lines.extend(view.remediation_note(
@@ -155,6 +156,7 @@ from ._prompt_sections import (  # noqa: E402,F401 - re-export after the split
     prompt_focus_sections,
     prompt_has_work,
     prompt_pressure_section,
+    prompt_security_pillar,
     prompt_semantic_section,
     prompt_tdd_section,
     prompt_work_order,

{maintainability_agent-3.6.2 → maintainability_agent-3.7.0}/src/maintainability_audit/renderers.py

@@ -214,6 +214,12 @@ def _bounded_markdown(report: dict[str, Any], score: dict[str, Any],
     lines.extend(summary)
     lines.extend(render_grade_blockers(report))
     lines.extend(score_table(score))
+    # The pillars, security among them, in the view most people read (D176).
+    # Rendered by the same function the complete report uses, so the two
+    # skins cannot disagree about a pillar (ADR 011); before this the chat
+    # view printed nothing about security at all, measured or not, and a
+    # missing pillar read exactly like a clean one (ADR 007).
+    lines.extend(pillars_markdown(report.get("pillars"), report.get("practice")))
     lines.extend([
         "---", "",
         "This is the bounded UI view. The complete report — every finding, "

{maintainability_agent-3.6.2 → maintainability_agent-3.7.0}/src/maintainability_audit/report.py

@@ -22,6 +22,7 @@ from ._economics import economic_context_from, economic_impact, reorder_by_expos
 from ._metrics_types import FileMetric, FunctionMetric
 from ._pillars import pillar_report
 from ._practice import practice_level
+from ._security_delegate import run_security_delegate
 from ._semantic import semantic_findings
 from ._semantic_policy import load_semantic_policy
 from ._semantic_ts import discover_type_analysis
@@ -399,27 +400,42 @@ def _attach_semantics(
 
 def _pillars_with_delegation(
     report: dict[str, Any], root: Path, pillar_path: str | None = None,
+    changed_revspec: str | None = None,
 ) -> list[dict[str, Any]]:
-    """The pillar block, with a delegated pillar's own report folded in.
-
-    ADR 007 §1 makes Security a delegated pillar naming
-    `secure-code-agent`, reported as `NotApplicable` so silence is never
-    read as safety. That was a placeholder for an artifact: when the
-    other tool has left `security-pillar.json` in the tree, the entry
-    carries its measurement instead of an apology for not having one.
-
-    Absent, the entry stays exactly what it was. Most repositories run
-    one tool, so that is the ordinary path and not a warning.
+    """The pillar block, with the delegated security pillar measured.
+
+    ADR 007 §1 makes Security a delegated pillar naming `secure-code-agent`.
+    Until D177 that was a handoff: the entry carried the other tool's
+    measurement only when a `security-pillar.json` had been left in the tree,
+    so every audit nobody had prepared — and every audit through the chat
+    door — reported the pillar unmeasured.
+
+    **The audit runs the delegate (D177).** An operator who names a document
+    with `--security-pillar` — CI, which runs secure-code-agent as its own
+    gated step — has that document used as given. Otherwise this audit runs
+    secure-code-agent itself. A `security-pillar.json` sitting in the tree is
+    no longer read on its own authority: it is repository content, and a
+    repository may not report its own security posture in place of a
+    measurement. When nothing trustworthy comes back, the entry says why.
 
     Its own function because `build_report` was at eighty lines against a
     limit of eighty, and adding this inline took it to eighty-eight —
     caught by this tool's gate on the commit that added it.
     """
-    handed_over = (read_delegated(root, pillar_path) if pillar_path
-                   else read_delegated(root))
+    if pillar_path:
+        handed_over = read_delegated(root, pillar_path)
+        reason = None if handed_over else (
+            f"the --security-pillar document {pillar_path} was absent or could not be trusted")
+    else:
+        run = run_security_delegate(root, changed_revspec=changed_revspec)
+        handed_over, reason = run.document, run.reason
+        if run.environment:
+            report["environment_work_order"] = [
+                *(report.get("environment_work_order") or []), *run.environment]
     return pillar_report(
         report["score"], report["practice"],
         {"security": handed_over} if handed_over else None,
+        {"security": reason} if reason else None,
     )
 
 
@@ -490,7 +506,7 @@ def build_report(
     report["score"] = score_report(report, analyzer["pressures"])
     # Condition rolls up aspects; practice stays a separate axis (ADR 007).
     report["practice"] = practice_level(root, config).as_dict()
-    report["pillars"] = _pillars_with_delegation(report, root, security_pillar)
+    report["pillars"] = _pillars_with_delegation(report, root, security_pillar, changed_revspec)
     _attach_semantics(report, root, config, only_paths)
     # Last, because every item's delta is a rubric recomputation and the
     # rubric needs the scored report to recompute against.