test(diff): assert no contained/unmerged fragments; QA.md sweep notes

Author: nikolay-e

QA.md

@@ -140,11 +140,15 @@ shadow:
 ```bash
 cd test-repos/<repo>
 git pull --ff-only
-# Hard-cap runtime. As of 3725f51b the CLI enforces `--timeout` as a true total
-# wall-clock bound (worker thread + watchdog) and fast-fails rc=124 with the
-# actionable-error contract instead of hanging to OOM (#70) — BUT the external
-# perl cap is still needed when smoking the **pipx** binary until that fix ships
-# in a release (pipx 1.10.0 has no watchdog). macOS has no `timeout`; use:
+# Hard-cap runtime. `--timeout` (true wall-clock bound, worker thread + watchdog,
+# fast-fails instead of hanging to OOM, #70, 3725f51b) lives ONLY on the
+# standalone Rust binary `diffctx/src/main.rs`. The **Python pipx wrapper does
+# NOT expose `--timeout` at all** — verified on the released `1.10.2`:
+# `diffctx --diff --help | grep timeout` → empty, and `grep -r timeout
+# src/diffctx/cli.py` → empty (the flag never crossed into the Python CLI). So
+# the external perl cap is MANDATORY for every pipx smoke regardless of release,
+# not just "until it ships" — the wrapper needs its own watchdog around the
+# pyo3 `compute_scored_state` call first. macOS has no `timeout`; use:
 perl -e 'alarm 200; exec @ARGV' /Users/nikolay/.local/bin/diffctx . --diff HEAD~1
 # (or, on the dev build, just pass `--timeout 200` — the watchdog bounds it.)
 ```
@@ -174,6 +178,26 @@ Either outcome — **all clean OR ≥1 issue filed** — is a valid completion o
 this step; the QA round proceeds to its remaining items either way. Do not let
 a found issue halt the round, and do not keep sweeping after one is filed.
 
+## Sweep Discriminator: EOF-Append to a Flat Data-List File (#103)
+
+A distinct symptom the file-count/token discriminators alone miss, surfaced
+sweeping `elasticsearch`: a diff whose ONLY change is a few lines **appended at
+EOF** of a large flat YAML/data-list file (e.g. `muted-tests.yml`, ~790 lines of
+top-level `- key: …` entries) produced an output with **zero `role: "changed"`
+fragments** — the changed lines never surfaced as a labeled change — while the
+whole file was exploded into ~118 per-entry `definition` context fragments plus
+a couple of unrelated files. Two separable defects: (A) **the change signal is
+lost** (correctness — worse than over-selection; `grep -c 'role:' out.yaml` → 0,
+and the max rendered line range stops BELOW the appended lines), and (B)
+whole-file fragmentation of a flat list (over-selection, overlaps #65). Tracked
+on #103, primarily for (A).
+
+**Add to the per-repo sweep judgment:** on any non-empty diff, assert
+`grep -c 'role: "changed"'` ≥ 1 AND that the output's max line range reaches the
+diff's changed lines. A clean rc=0 with a plausible token count still hides this
+class — `role:`-absence is the tell. Contrast a healthy run (`numpy HEAD~1`:
+5 `role: "changed"` fragments, context scoped to 2 tightly-related stubs).
+
 ## Local `which diffctx` Trap — diffctx specifics
 
 See `/qa` skill: Packaging QA (`which`-vs-pipx). Concretely: when this project's

tests/test_diffctx_invariants.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import itertools
 import re
 import subprocess
 import sys
@@ -243,6 +244,55 @@ def test_diff_context_merges_contiguous_fragments(tmp_path):
         assert start <= end, f"fragment line range inverted: {f['lines']}"
 
 
+def test_diff_context_no_contained_or_unmerged_fragments(tmp_path):
+    """Regression (f1a1647d): the render merge pass must, per (path, role),
+    drop any fragment fully contained in another and merge line-contiguous
+    runs. A change editing several functions in one file produces multiple
+    same-role fragments, exercising that pass; the output must never carry a
+    range nested inside a sibling nor an unmerged `next.start == cur.end + 1`
+    pair (both are pure per-fragment scaffolding duplication)."""
+    import json
+    from collections import defaultdict
+
+    repo = Pygit2Repo(tmp_path / "repo")
+    base_src = "".join(f"def f{i}(x):\n    y = x + {i}\n    return y\n\n" for i in range(12))
+    repo.add_file("src/mod.py", base_src)
+    repo.add_file("src/other.py", "from mod import f0, f5, f11\n\ndef run():\n    return f0(1) + f5(2) + f11(3)\n")
+    base = repo.commit("init")
+    edited_src = "".join(
+        (
+            f"def f{i}(x):\n    y = x * {i}\n    z = y + 1\n    return z\n\n"
+            if i in (2, 5, 9)
+            else f"def f{i}(x):\n    y = x + {i}\n    return y\n\n"
+        )
+        for i in range(12)
+    )
+    repo.add_file("src/mod.py", edited_src)
+    head = repo.commit("edit several functions")
+
+    stdout, _ = _run(repo.path, [".", "--diff", f"{base}..{head}", "--budget", "8000", "-f", "json"])
+    fragments = json.loads(stdout)["fragments"]
+
+    by_key: dict[tuple[str, str | None], list[tuple[int, int]]] = defaultdict(list)
+    for f in fragments:
+        start, end = (int(x) for x in f["lines"].split("-"))
+        by_key[(f["path"], f.get("role"))].append((start, end))
+
+    assert any(
+        len(ranges) >= 2 for ranges in by_key.values()
+    ), "fixture must yield a multi-fragment group to exercise the merge pass"
+
+    for (path, role), ranges in by_key.items():
+        ordered = sorted(ranges)
+        for (a_start, a_end), (b_start, b_end) in itertools.pairwise(ordered):
+            assert not (
+                b_start >= a_start and b_end <= a_end
+            ), f"contained fragment {(b_start, b_end)} inside {(a_start, a_end)} for {path} role={role}"
+            assert (
+                b_start != a_end + 1
+            ), f"unmerged contiguous fragments {(a_start, a_end)} and {(b_start, b_end)} for {path} role={role}"
+
+
 def test_diff_context_scopes_markdown_preamble_change_not_whole_file(tmp_path):
     """Regression (#91): a change to a lone H1's own preamble (before its
     first `##` child heading) used to select a fragment spanning the H1's