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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maintainability-agent
-Version: 3.6.1
+Version: 3.6.2
 Summary: Maintainability gate and AI remediation prompt generator for CI.
 Author: Marshall Guillory
 License: MIT
@@ -46,7 +46,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.1**.
+Version **3.6.2**.
 
 **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.1 → maintainability_agent-3.6.2}/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.1**.
+Version **3.6.2**.
 
 **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.1 → maintainability_agent-3.6.2}/pyproject.toml

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maintainability-agent
-Version: 3.6.1
+Version: 3.6.2
 Summary: Maintainability gate and AI remediation prompt generator for CI.
 Author: Marshall Guillory
 License: MIT
@@ -46,7 +46,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.1**.
+Version **3.6.2**.
 
 **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.1 → maintainability_agent-3.6.2}/src/maintainability_agent.egg-info/SOURCES.txt

@@ -236,6 +236,7 @@ tests/test_economic_context.py
 tests/test_empty_output_not_clean.py
 tests/test_empty_output_not_clean_adapters.py
 tests/test_environment_work_order.py
+tests/test_every_surface_says_what_the_run_found.py
 tests/test_evidence_invariants.py
 tests/test_evidence_normalization.py
 tests/test_evidence_properties.py

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

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

{maintainability_agent-3.6.1 → maintainability_agent-3.6.2}/src/maintainability_audit/_precommit.py

@@ -171,6 +171,11 @@ def staged_report(root: Path, config: dict[str, Any]) -> dict[str, Any]:
     return {
         "root": str(root),
         "scanned": scannable,
+        # The limits these hotspots were graded against, so the work-order
+        # builder can name them. Without this the hook worded a class
+        # "graded on length alone" while the audit said "against the
+        # 300-line class limit" (D171).
+        "thresholds": thresholds,
         "largest_files": largest,
         "function_hotspots": hotspots,
         "risk_findings": risk,
@@ -288,7 +293,7 @@ def staged_findings(report: dict[str, Any]) -> list[dict[str, Any]]:
     from ._work_order import _items_from_files, _items_from_hotspots, band_of
 
     items: list[dict[str, Any]] = []
-    for entry in _items_from_hotspots(report) + _items_from_files(report):
+    for entry in _items_from_hotspots(report, report.get("thresholds")) + _items_from_files(report):
         weight = entry.pop("weight")
         rationale = entry.pop("rationale", None) or weight.rationale
         items.append({**entry, "rationale": rationale,

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

@@ -89,7 +89,17 @@ def prompt_analyzer_caveat(report: dict[str, Any]) -> list[str]:
     """
     if not (report.get("analyzer_measurements") or report.get("analyzer_findings")):
         return []
-    scored = (report.get("score") or {}).get("analyzer_scored_dimensions") or []
+    score = report.get("score") or {}
+    if not view.is_scored(score):
+        # No estimate was issued, so none can have a source (D172). The
+        # analyzer output is still evidence about the code, and says so.
+        return [
+            "**No maintainability estimate was issued for this run**, so none is "
+            "attributed to the analyzers. Their output is reported here as "
+            "evidence about the code, never as a change to a score.",
+            "",
+        ]
+    scored = score.get("analyzer_scored_dimensions") or []
     if scored:
         return [
             "**The maintainability estimate above uses the analyzer readings** for "
@@ -149,6 +159,50 @@ def _withheld_paragraph(report: dict[str, Any]) -> list[str]:
     ]
 
 
+def _prompt_work_items(report: dict[str, Any]) -> list[dict[str, Any]]:
+    """The items this prompt hands to an agent, after withholding."""
+    # Withhold anything the history shows was fixed and came back
+    # twice. Naming it as a design candidate while asking an agent to
+    # patch it a third time would change nothing.
+    escalated = {
+        item["fingerprint"] for item in report.get("design_review_candidates") or []
+    }
+    return prompt_items(report.get("work_order") or [], escalated=escalated)
+
+
+def prompt_has_work(report: dict[str, Any]) -> bool:
+    """Whether this prompt hands an agent anything to change (D173).
+
+    A report with no `work_order` key at all — stored before the field
+    existed, or assembled by hand — cannot say there is nothing to do, so
+    it keeps the prompt it always had rather than reading as "Nothing to
+    do" over findings it does carry.
+    """
+    return "work_order" not in report or bool(_prompt_work_items(report))
+
+
+def _no_prompt_work(report: dict[str, Any]) -> list[str]:
+    """What the prompt says in place of a task when there is none (D173).
+
+    Two cases, because they are different facts. An empty work order is the
+    chat report's "Nothing to do", in the same words. A work order whose
+    every item was withheld — a Major Project, or a finding escalated for
+    design review — has work in it, none of it an agent's to patch.
+    """
+    if not report.get("work_order"):
+        from ._work_order_view import NOTHING_TO_DO
+
+        return [NOTHING_TO_DO, "", "Do not change code on the strength of this audit.", ""]
+    return [
+        "**Nothing in scope for this prompt.** Every work-order item needs a "
+        "design decision or keeps coming back, so none is handed to an agent. "
+        "They are in the report. Do not change code on the strength of this "
+        "prompt.",
+        "",
+        *_withheld_paragraph(report),
+    ]
+
+
 def prompt_work_order(report: dict[str, Any]) -> list[str]:
     """The ordered work, leading the prompt, Major Projects withheld.
 
@@ -161,15 +215,9 @@ def prompt_work_order(report: dict[str, Any]) -> list[str]:
     told to deduplicate a pattern across forty files produces exactly the
     sprawling, unreviewable diff a bounded prompt exists to prevent.
     """
-    # Withhold anything the history shows was fixed and came back
-    # twice. Naming it as a design candidate while asking an agent to
-    # patch it a third time would change nothing.
-    escalated = {
-        item["fingerprint"] for item in report.get("design_review_candidates") or []
-    }
-    items = prompt_items(report.get("work_order") or [], escalated=escalated)
+    items = _prompt_work_items(report)
     if not items:
-        return []
+        return _no_prompt_work(report) if "work_order" in report else []
     lines = [
         # What the order is, not what it is worth (D169): `prompt_items`
         # promotes risk-5 classes and keeps one item per class, so this

{maintainability_agent-3.6.1 → maintainability_agent-3.6.2}/src/maintainability_audit/_work_order.py

@@ -483,8 +483,9 @@ def prompt_items(items: list[dict[str, Any]], limit: int = 12,
                  escalated: set[str] | None = None) -> list[dict[str, Any]]:
     """Agent subset: no major projects, no escalated returns; Severe leads.
 
-    Economic reorder may bury a risk-5 item under hot-file Fill-Ins. The
-    table can stay exposure-ordered; the paste of 12 cannot drop Severe.
+    The economic reorder orders items by exposure within each band (D170),
+    so a risk-5 item can still sit below hotter Quick Wins of other classes.
+    The table can stay exposure-ordered; the paste of 12 cannot drop Severe.
     """
     blocked = escalated or set()
     eligible = [

{maintainability_agent-3.6.1 → maintainability_agent-3.6.2}/src/maintainability_audit/_work_order_view.py

@@ -85,10 +85,11 @@ def item_prompt_block(item: dict[str, Any], root_label: str = ".") -> list[str]:
 #: The order sentence, by which sort actually produced the list (D169).
 #:
 #: `reorder_by_exposure` re-sorts the stored work order by recurrence and
-#: churn whenever an economic context is configured, ignoring band. The
-#: heading went on saying "ordered by what it costs to leave against what
-#: it costs to fix" over a list that sort had replaced, so the table and the
-#: prompt named different first items and neither said why.
+#: churn whenever an economic context is configured — within each band
+#: since D170, across bands before it. The heading went on saying "ordered
+#: by what it costs to leave against what it costs to fix" over a list that
+#: sort had reordered, so the table and the prompt named different first
+#: items and neither said why.
 _ORDER_BY_BAND = (
     "Ordered by what it costs to leave against what it costs to fix "
     "(see the standard)."
@@ -97,6 +98,14 @@ _ORDER_BY_EXPOSURE = (
     "Ordered by band, then by exposure within each band — how often a "
     "finding came back and how much its file changes (ADR 004)."
 )
+#: What a run with no work order says, on every skin that would otherwise
+#: hand over a task (D173). The chat report said this while the prompt from
+#: the same run asked for "the smallest coherent patch".
+NOTHING_TO_DO = (
+    "**Nothing to do.** No finding reached a band worth a work-order "
+    "item, so there is no prompt to paste. The evidence behind that is "
+    "below."
+)
 _BAND_IS_PER_CLASS = (
     "A band is declared per kind of finding in the standard, not sized per "
     "item: each target states that item's own reading."

{maintainability_agent-3.6.1 → maintainability_agent-3.6.2}/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.1"
+VERSION = "3.6.2"
 
 PROJECT_URL = "https://github.com/marshallguillory86/maintainability-agent"
 

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

@@ -32,23 +32,17 @@ def render_ai_prompt(report: dict[str, Any]) -> str:
     """
     summary = report["summary"]
     score = report["score"]
+    # A run with nothing in scope hands over no task (D173): the chat report
+    # from the same run said "Nothing to do" while this file asked for a
+    # patch and listed warn-band hotspots the work order had refused.
+    has_work = prompt_has_work(report)
     lines = [
         "# AI Remediation Prompt",
         "",
         "You are working in a git repository that has just produced a maintainability audit.",
         "",
-        "Your task is to fix the highest-value maintainability issues in a small, reviewable change.",
-        "",
-        "Rules:",
-        "",
-        "- Do not rewrite the whole codebase.",
-        "- Do not change public behavior unless a finding explicitly requires it.",
-        "- Prefer existing architecture, naming, and local patterns.",
-        "- Add or update tests for meaningful behavior before changing production code where practical.",
-        "- Keep unrelated refactors out of scope.",
-        "- If a finding is a false positive, explain why and leave the code unchanged.",
-        "- After changes, run the repo's native tests/lints and this maintainability audit again.",
-        "",
+        *(_TASK if has_work else ()),
+        *_RULES,
     ]
     # The product, before anything describing the run that produced it.
     lines.extend(prompt_escalation_note(report))
@@ -82,11 +76,32 @@ def render_ai_prompt(report: dict[str, Any]) -> str:
     lines.extend(prompt_tdd_section(report))
     lines.extend(prompt_semantic_section(report))
     lines.extend(prompt_pressure_section(score, (report.get("summary") or {}).get("languages")))
-    lines.extend(prompt_focus_sections(report))
-    lines.extend(prompt_deliverable())
+    if has_work:
+        lines.extend(prompt_focus_sections(report))
+        lines.extend(prompt_deliverable())
     return "\n".join(lines)
 
 
+_TASK = (
+    "Your task is to fix the highest-value maintainability issues in a small, reviewable change.",
+    "",
+)
+# Kept on every prompt: they bound what an agent may do, and a run with
+# nothing in scope is still bounded by them.
+_RULES = (
+    "Rules:",
+    "",
+    "- Do not rewrite the whole codebase.",
+    "- Do not change public behavior unless a finding explicitly requires it.",
+    "- Prefer existing architecture, naming, and local patterns.",
+    "- Add or update tests for meaningful behavior before changing production code where practical.",
+    "- Keep unrelated refactors out of scope.",
+    "- If a finding is a false positive, explain why and leave the code unchanged.",
+    "- After changes, run the repo's native tests/lints and this maintainability audit again.",
+    "",
+)
+
+
 def render_agent_instructions(report: dict[str, Any]) -> str:
     return "\n".join(
         [
@@ -138,6 +153,7 @@ from ._prompt_sections import (  # noqa: E402,F401 - re-export after the split
     prompt_deliverable,
     prompt_escalation_note,
     prompt_focus_sections,
+    prompt_has_work,
     prompt_pressure_section,
     prompt_semantic_section,
     prompt_tdd_section,

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

@@ -32,7 +32,7 @@ from ._scan_view import (
 )
 from ._semantic_view import semantic_markdown, without_semantic_suffixes
 from ._tdd_view import tdd_structure_markdown
-from ._work_order_view import work_order_markdown, work_order_selection_markdown
+from ._work_order_view import NOTHING_TO_DO, work_order_markdown, work_order_selection_markdown
 
 
 def _pool_ran(report: dict[str, Any]) -> bool:
@@ -188,13 +188,7 @@ def _no_work_order_lines() -> list[str]:
     "nothing met the bands" from "this tool does not do that" — and the
     second reading is the one a stranger takes on a first run.
     """
-    return [
-        "## Work Order", "",
-        "**Nothing to do.** No finding reached a band worth a work-order "
-        "item, so there is no prompt to paste. The evidence behind that is "
-        "below.",
-        "",
-    ]
+    return ["## Work Order", "", NOTHING_TO_DO, ""]
 
 
 def _bounded_markdown(report: dict[str, Any], score: dict[str, Any],

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

@@ -367,17 +367,33 @@ def _assemble(
     }
 
 
-def _attach_semantics(report: dict[str, Any], root: Path, config: dict[str, Any]) -> None:
+def _attach_semantics(
+    report: dict[str, Any], root: Path, config: dict[str, Any],
+    only_paths: set[str] | None = None,
+) -> None:
     """ADR 003 option C, after the score is sealed and before the work
     order reads it: semantic results are findings and prompt material,
     never rubric input — nothing from here reaches `score_report`.
+
+    **A changed-only run keeps the findings its paths hold (D174).** The
+    semantic walk reads the whole tree, so a changed-only audit of two
+    commits nominated a TypeScript fixture neither commit touched and
+    handed it to the prompt. A finding with no located source path cannot
+    be placed in or out of the change, and is not work anyone can act on
+    either (`_items_from_semantic` drops it), so it is left out here too.
     """
     semantic = semantic_findings(
         root,
         policy=load_semantic_policy(config),
         type_analysis=discover_type_analysis(root),
     )
-    report["semantic_findings"] = semantic["findings"]
+    findings = semantic["findings"]
+    if only_paths is not None:
+        findings = [
+            finding for finding in findings
+            if ((finding.get("source_evidence") or {}).get("path")) in only_paths
+        ]
+    report["semantic_findings"] = findings
     report["semantic_coverage"] = semantic["coverage"]
 
 
@@ -475,7 +491,7 @@ def build_report(
     # 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)
-    _attach_semantics(report, root, config)
+    _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.
     report["work_order"] = work_order(report, thresholds=config["thresholds"])

{maintainability_agent-3.6.1 → maintainability_agent-3.6.2}/tests/test_declaration_grading.py

@@ -174,8 +174,17 @@ def test_function_hotspot_still_reports_its_complexity() -> None:
 
 def test_class_label_reaches_the_prompt_the_pr_comment_and_sarif() -> None:
     report = flagged_class_report()
-
-    assert "`ScanWorker` (class) (260 lines, warn)" in render_ai_prompt(report)
+    # The prompt lists hotspots only when it hands over work (D173); a
+    # warn-only run is "Nothing to do" there. Give the prompt one item so
+    # its hotspot section — where the label is checked — renders.
+    prompted = {**report, "work_order": [{
+        "finding_class": "oversized-declaration", "title": "ScanWorker in scanner.py",
+        "path": "scanner.py", "line": 1, "band": "quick-win", "risk": 4, "effort": 2,
+        "target": "t", "rationale": "r", "verification": "v", "class_delta": 0.0,
+        "class_count": 1, "fingerprint": "fp", "severity": 1.0,
+    }]}
+
+    assert "`ScanWorker` (class) (260 lines, warn)" in render_ai_prompt(prompted)
     assert "`ScanWorker` (class) (260 lines, warn)" in render_pr_comment(report)
     message = report_to_sarif(report)["runs"][0]["results"][0]["message"]["text"]
     assert message == "ScanWorker (class) (260 lines, warn)."

maintainability_agent-3.6.2/tests/test_every_surface_says_what_the_run_found.py

@@ -0,0 +1,239 @@
+"""Every surface of one run says what that run found, and nothing else.
+
+D171–D174, from Grok's hostile audit of `77de21c` (3.6.0 + 3.6.1). Each is
+one surface telling a different story from the report it belongs to:
+
+* D171 — the pre-commit hook worded a declaration unlike the audit.
+* D172 — the prompt named a source for an estimate that was not issued.
+* D173 — the prompt asked for a patch on a run whose report said
+  "Nothing to do".
+* D174 — a changed-only run handed the prompt a finding from a file the
+  change never touched.
+
+Populations are derived: declarations from every grammar fixture on disk,
+dimensions from the score document, the "patch" instructions from
+`prompt_deliverable` itself, and semantic findings from a tree carrying the
+semantic fixture at several locations. Each sweep asserts it is not empty.
+"""
+from __future__ import annotations
+
+import copy
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[1]
+GRAMMAR = ROOT / "tests" / "fixtures" / "grammar"
+
+
+def _failing_everything() -> dict[str, Any]:
+    """Every declaration breaches; class and function budgets differ, so a
+    target naming the wrong one is visible."""
+    from maintainability_audit.config import load_config
+
+    config = copy.deepcopy(load_config(None))
+    config["thresholds"].update({
+        "max_function_lines": 3, "warn_function_lines": 2,
+        "max_class_lines": 1, "warn_class_lines": 1,
+        "max_complexity": 0, "warn_complexity": 0,
+    })
+    return config
+
+
+def _git(repo: Path, *args: str) -> None:
+    subprocess.run(["git", "-C", str(repo), *args], check=True, capture_output=True)
+
+
+def test_the_hook_words_every_declaration_as_the_audit_does(tmp_path) -> None:
+    """D171: `staged_findings` and the audit give one target per declaration.
+
+    D164 passed thresholds to `_items_from_hotspots` from `build_report` and
+    `check_content` but not from the hook, so a staged 2876-line class read
+    "a class is graded on length alone" where the audit read "against the
+    300-line class limit".
+    """
+    from maintainability_audit._precommit import staged_findings, staged_report
+    from maintainability_audit.report import build_report
+
+    fixtures = sorted(GRAMMAR.rglob("constructs.*"))
+    assert fixtures, f"no grammar fixtures under {GRAMMAR}; this sweep would pass vacuously"
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    _git(repo, "init", "-q")
+    for fixture in fixtures:
+        shutil.copy(fixture, repo / fixture.name)
+    _git(repo, "add", ".")
+    config = _failing_everything()
+
+    def targets(items: list[dict[str, Any]]) -> dict[tuple[str, int], str]:
+        return {(item["path"], item["line"]): item["target"] for item in items
+                if item["finding_class"] == "oversized-declaration"}
+
+    hook = targets(staged_findings(staged_report(repo, config)))
+    audit = targets(build_report(repo, config, run_analyzers=False)["work_order"])
+    assert any("-line class limit" in target for target in audit.values()), (
+        "the audit produced no class targets, so the class half was never compared"
+    )
+    shared = hook.keys() & audit.keys()
+    assert shared, "the hook and the audit located no declaration in common"
+    differing = {key: (hook[key], audit[key]) for key in shared if hook[key] != audit[key]}
+    assert not differing, f"hook and audit word these declarations differently: {list(differing.items())[:3]}"
+
+
+def _unscored_report(root: Path) -> dict[str, Any]:
+    from maintainability_audit.config import load_config
+    from maintainability_audit.report import build_report
+
+    root.mkdir()
+    body = "".join(f"    value = {line}\n" for line in range(900))
+    (root / "module.py").write_text(f"def value():\n{body}    return value\n", encoding="utf-8")
+    report = build_report(root, load_config(None), run_analyzers=False)
+    assert report["score"]["maintainability_estimate"] is None, "the tree was scored; the floors did not hold"
+    return report
+
+
+@pytest.mark.usefixtures("real_population_floors")
+def test_no_prompt_names_a_source_for_an_estimate_that_was_not_issued(tmp_path) -> None:
+    """D172: with no estimate, neither caveat branch attributes one.
+
+    `prompt_analyzer_caveat` said "the maintainability estimate above uses the
+    analyzer readings" beside "Maintainability estimate: Not scored". The
+    other branch — "comes from the built-in detectors" — made the same claim
+    about the same absent number.
+    """
+    from maintainability_audit.prompts import render_ai_prompt
+
+    base = _unscored_report(tmp_path / "tree")
+    dimensions = sorted(base["score"]["dimensions"])
+    assert dimensions, "the score document names no dimensions"
+    states = [[], *([name] for name in dimensions)]
+    wrong = []
+    for scored in states:
+        report = copy.deepcopy(base)
+        report["analyzer_measurements"] = [{"tool": "lizard"}]
+        report["score"]["analyzer_scored_dimensions"] = scored
+        prompt = render_ai_prompt(report)
+        if "maintainability estimate above" in prompt.lower():
+            wrong.append(scored)
+    assert not wrong, f"unscored prompts attributing an estimate, by scored dimensions: {wrong}"
+
+
+def _deliverable_lines() -> list[str]:
+    from maintainability_audit._prompt_sections import prompt_deliverable
+
+    lines = [line for line in prompt_deliverable() if len(line.strip()) > 12]
+    assert lines, "prompt_deliverable produced no instruction lines"
+    return lines
+
+
+def _task_lines(prompt: str) -> list[str]:
+    handed = [line for line in _deliverable_lines() if line in prompt]
+    if "Your task is to fix" in prompt:
+        handed.append("Your task is to fix")
+    if "Function hotspots to inspect first" in prompt:
+        handed.append("Function hotspots to inspect first")
+    return handed
+
+
+def test_a_run_with_no_work_order_hands_the_prompt_no_task(tmp_path) -> None:
+    """D173: a warn-only run is "Nothing to do" in the chat report and the prompt alike."""
+    from maintainability_audit._work_order_view import NOTHING_TO_DO
+    from maintainability_audit.config import load_config
+    from maintainability_audit.prompts import render_ai_prompt
+    from maintainability_audit.renderers import render_markdown
+    from maintainability_audit.report import build_report
+
+    config = load_config(None)
+    thresholds = config["thresholds"]
+    between = (thresholds["warn_function_lines"] + thresholds["max_function_lines"]) // 2
+    tree = tmp_path / "warn"
+    tree.mkdir()
+    body = "".join(f"    v = {line}\n" for line in range(between - 2))
+    (tree / "module.py").write_text(f"def warned():\n{body}    return v\n", encoding="utf-8")
+    report = build_report(tree, config, run_analyzers=False)
+    assert report["function_hotspots"], "no hotspot at all; the warn band was never reached"
+    assert report["work_order"] == [], f"the tree produced work: {report['work_order']}"
+    assert NOTHING_TO_DO in render_markdown(report, complete=False)
+
+    prompt = render_ai_prompt(report)
+    assert NOTHING_TO_DO in prompt, "the prompt does not say what the chat report says"
+    assert not _task_lines(prompt), f"a 'Nothing to do' run's prompt still hands over: {_task_lines(prompt)}"
+
+
+def test_a_work_order_withheld_whole_hands_the_prompt_no_task(tmp_path) -> None:
+    """D173's second case: every item withheld from the prompt is not a job either."""
+    from maintainability_audit.config import load_config
+    from maintainability_audit.prompts import render_ai_prompt
+    from maintainability_audit.report import build_report
+
+    tree = tmp_path / "tree"
+    tree.mkdir()
+    (tree / "a.py").write_text("def a():\n    return 1\n", encoding="utf-8")
+    report = build_report(tree, load_config(None), run_analyzers=False)
+    report["work_order"] = [{
+        "finding_class": "duplicate-block", "title": "duplicated block in a.py", "path": "a.py",
+        "line": 1, "band": "major-project", "risk": 4, "effort": 4, "target": "t",
+        "rationale": "r", "verification": "v", "class_delta": 0.0, "class_count": 1,
+        "fingerprint": "fp", "severity": 1.0,
+    }]
+    prompt = render_ai_prompt(report)
+    assert "Nothing in scope for this prompt" in prompt
+    assert not _task_lines(prompt), f"a fully withheld work order still hands over: {_task_lines(prompt)}"
+
+
+def test_a_prompt_with_work_still_hands_over_its_task(tmp_path) -> None:
+    """D173 must not strip the task where there is one.
+
+    Covers existing behaviour: a run with work already carried its task and
+    deliverable; this guards the D173 narrowing against removing them.
+    """
+    from maintainability_audit.config import load_config
+    from maintainability_audit.prompts import render_ai_prompt
+    from maintainability_audit.report import build_report
+
+    tree = tmp_path / "tree"
+    tree.mkdir()
+    body = "".join(f"    v = {line}\n" for line in range(120))
+    (tree / "module.py").write_text(f"def huge():\n{body}    return v\n", encoding="utf-8")
+    report = build_report(tree, load_config(None), run_analyzers=False)
+    assert report["work_order"], "the fixture produced no work"
+    prompt = render_ai_prompt(report)
+    assert all(line in prompt for line in _deliverable_lines())
+    assert "Your task is to fix" in prompt
+
+
+def test_a_changed_only_run_hands_over_no_semantic_finding_outside_its_paths(tmp_path) -> None:
+    """D174: a semantic finding is kept exactly where its source path is in the change.
+
+    The semantic walk reads the whole tree; changed-only over two commits
+    handed the prompt `tests/fixtures/semantic_ts/src/operations.ts`, which
+    neither touched. This repository holds that one located finding, so a
+    population drawn from it would be the sample itself: the tree here
+    carries every copy of the semantic fixture at more than one location,
+    and a change that touches one of them.
+    """
+    from maintainability_audit._semantic import semantic_findings
+    from maintainability_audit._semantic_ts import discover_type_analysis
+    from maintainability_audit.config import load_config
+    from maintainability_audit.prompts import render_ai_prompt
+    from maintainability_audit.report import build_report
+
+    fixture = ROOT / "tests" / "fixtures" / "semantic_ts"
+    tree = tmp_path / "tree"
+    for place in ("lib/alpha", "services/beta", "tools/gamma"):
+        shutil.copytree(fixture, tree / place)
+    full = semantic_findings(tree, type_analysis=discover_type_analysis(tree))["findings"]
+    located = sorted({(finding.get("source_evidence") or {}).get("path") for finding in full} - {None})
+    assert len(located) >= 2, f"the tree located {located}; nothing to keep one of and drop the rest"
+    changed = located[0]
+    report = build_report(tree, load_config(None), only_paths={changed},
+                          changed_revspec="HEAD~1...HEAD", run_analyzers=False)
+    kept = sorted({(finding.get("source_evidence") or {}).get("path")
+                   for finding in report["semantic_findings"]})
+    assert kept == [changed], f"changed-only over {changed} kept semantic findings at {kept}"
+    prompt = render_ai_prompt(report)
+    named = [path for path in located[1:] if path in prompt]
+    assert not named, f"the changed-only prompt names files outside the change: {named}"