leyline-code 0.8.1__py3-none-any.whl

leyline/related.py

@@ -0,0 +1,266 @@
+"""Earlier changes to the same code: what was decided there is worth reading before changing it again.
+
+`leyline plan` and `leyline pr` list up to five earlier changes that touched the code a change touches, newest first,
+each with its id, title, date and the names they share. Two kinds of earlier change are indexed by the nodes they
+touched:
+
+- OpenSpec changes that are finished: archived (`openspec/changes/archive/<date>-<id>/`), or checked (`leyline check`
+  ran on them). Their nodes come from the store (the tasks' code, `spec_items`; the code their check found edited,
+  the review view's marks; the code they planned to change, the plan view's marks), from the anchors `check` keeps
+  in `openspec/leyline-anchors.json`, and, for a folder the store knows nothing of, from the code its tasks and
+  spec deltas name.
+- Pull requests reviewed with `leyline pr`: the code each one edited and added (its view's marks).
+
+A repository with neither falls back on git history, the cheap way: the commits before the change (at most 500, merges
+and bulk commits left out) that changed the files the change touches, the most such files first. A commit's line
+numbers are those of its own time, so placing its hunks in today's functions would mean parsing each file as it
+was; files are what it can say for sure.
+"""
+
+from __future__ import annotations
+
+import datetime
+import json
+import re
+from pathlib import Path
+from typing import Optional
+
+from . import store
+
+LIMIT = 5
+MAX_COMMITS = 500
+BULK = 50           # a commit that changed more files than this is a bulk change (a formatter, a rename), left out
+CHANGED_ROLES = ("changed", "new", "edited as predicted", "new, as declared", "edited, not predicted")
+
+
+def _near(a: str, b: str) -> bool:
+    return a == b or b.startswith((a + ".", a + "(", a + "/")) or a.startswith((b + ".", b + "(", b + "/"))
+
+
+def _marks(con, view_id: str) -> list[str]:
+    row = con.execute("SELECT spec FROM views WHERE id = ?", (view_id,)).fetchone()
+    if not row:
+        return []
+    try:
+        return [m["id"] for m in json.loads(row[0] or "{}").get("marks", []) if m.get("role") in CHANGED_ROLES]
+    except (ValueError, TypeError, KeyError):
+        return []
+
+
+def _view_date(con, view_id: str) -> str:
+    row = con.execute("SELECT created FROM views WHERE id = ?", (view_id,)).fetchone()
+    return (row[0] or "")[:10] if row else ""
+
+
+def _stored_nodes(con, cid: str) -> set:
+    """What the store says a spec change touched: its tasks' code, and the code its plan and check marked."""
+    out = set()
+    for r in con.execute("SELECT nodes, attrs FROM spec_items WHERE change_id = ? AND kind = 'task'", (cid,)):
+        try:
+            out |= set(json.loads(r[0] or "[]"))
+            out |= set((json.loads(r[1] or "{}") or {}).get("into") or [])
+        except ValueError:
+            continue
+    out |= set(_marks(con, "view-review-" + cid)) | set(_marks(con, "view-" + cid))
+    return out
+
+
+def _full(names, repos: list[str], local: str) -> Optional[str]:
+    """An anchor's node id, written without the repository's id, as an id on this map."""
+    if local in names.by_id:
+        return local
+    return next((f"{r}:{local}" for r in repos if f"{r}:{local}" in names.by_id), None)
+
+
+def _named(names, folder: Path) -> set:
+    """The code a change folder's tasks and spec deltas name, resolved on the map as it is now."""
+    from . import drift
+    out = set()
+    try:
+        for w in drift._change_names(folder):
+            out |= set(names.resolve(w).get("ids") or [])
+    except (OSError, ValueError):
+        pass
+    return out
+
+
+def _verdict(folder: Path) -> Optional[str]:
+    """The date `leyline check` last found this folder's change done, from its page, or None."""
+    page = folder / "leyline.md"
+    try:
+        text = page.read_text(encoding="utf-8", errors="replace")
+        verdict = text.split("## 4. Was it done as agreed", 1)[1] if "## 4. Was it done as agreed" in text else ""
+        if re.search(r"^\*\*Yes\.\*\*", verdict, re.M):
+            return datetime.date.fromtimestamp(page.stat().st_mtime).isoformat()
+    except OSError:
+        pass
+    return None
+
+
+def index(con, names) -> list[dict]:
+    """Every finished OpenSpec change and every reviewed pull request, with the nodes each touched."""
+    from . import drift, spec
+    repos = list(store.roots(con))
+    out: dict[str, dict] = {}
+    for osp in drift.places(con):
+        anchors, _ = drift.load(con, osp)
+        changes = osp / "changes"
+        folders = []
+        if changes.is_dir():
+            folders += [(f, "checked") for f in sorted(changes.iterdir()) if f.is_dir() and f.name != "archive"]
+        if (changes / "archive").is_dir():
+            folders += [(f, "archived") for f in sorted((changes / "archive").iterdir()) if f.is_dir()]
+        for folder, state in folders:
+            key = drift.DATED.sub("", folder.name)
+            cid = "spec-" + key
+            row = con.execute("SELECT attrs, intent, status FROM change_proposals WHERE id = ?", (cid,)).fetchone()
+            attrs = json.loads(row[0] or "{}") if row else {}
+            if state == "archived":
+                date = folder.name[:10] if drift.DATED.match(folder.name) else (attrs.get("verified") or "")[:10]
+            else:
+                # Finished while its last check found it done: one that failed since, or was planned again, is not.
+                # A folder the store does not know is read from its page.
+                date = ((attrs.get("verified") or "")[:10] if row[2] == "verified" else "") if row else _verdict(folder)
+                if not date:
+                    continue   # still being worked on: not an earlier change
+            nodes = _stored_nodes(con, cid)
+            nodes |= {i for a in (anchors.get(key) or {}).get("anchors", []) if (i := _full(names, repos, a.get("node", "")))}
+            if not nodes:
+                nodes = _named(names, folder)
+            try:
+                title = spec.parse(folder).get("title") or key
+            except OSError:
+                title = attrs.get("title") or key
+            out[cid] = {"id": key, "change_id": cid, "kind": state, "title": title, "date": date or "", "nodes": nodes,
+                        "where": str(folder)}
+    for r in con.execute("SELECT id, intent, attrs FROM change_proposals"):
+        attrs = json.loads(r["attrs"] or "{}")
+        if attrs.get("kind") != "pr" or r["id"] in out:
+            continue
+        from . import rereview
+        try:
+            date = (rereview.last_reviewed(con, r["id"]) or "")[:10]
+        except Exception:
+            date = ""
+        out[r["id"]] = {"id": r["id"], "change_id": r["id"], "kind": "review", "title": attrs.get("title") or (r["intent"] or "")[:80],
+                        "date": date or _view_date(con, "view-" + r["id"]), "nodes": set(_marks(con, "view-" + r["id"]))}
+    return [x for x in out.values() if x["nodes"]]
+
+
+def _label(names, i: str) -> str:
+    from . import spec
+    return spec._label(names, i) if i in names.by_id else i.rsplit(":", 1)[-1]
+
+
+def overlap(names, current: list[str], past: set) -> list[str]:
+    """The names of the code a change touches that an earlier change touched too: the same node, one inside the
+    other (a method of a type it changed), or a function in a file it changed."""
+    files = {p for p in past if (names.by_id.get(p) or {"kind": ""})["kind"] == "file"}
+    hits = []
+    for c in current:
+        row = names.by_id.get(c)
+        if any(_near(c, p) for p in past) or (row is not None and files and
+                                              any(f for f in files if names.by_id[f]["path"] == row["path"])):
+            hits.append(_label(names, c))
+    return list(dict.fromkeys(hits))
+
+
+def find(con, names, current: list[str], exclude: Optional[str] = None, since: Optional[str] = None,
+         limit: int = LIMIT) -> dict:
+    """Up to `limit` earlier changes to the code a change touches. {"source", "about", "items", "total"}, or {}."""
+    current = [c for c in dict.fromkeys(current) if c]
+    if not current:
+        return {}
+    try:
+        found = []
+        for x in index(con, names):
+            if x["change_id"] == exclude:
+                continue
+            shared = overlap(names, current, x["nodes"])
+            if shared:
+                found.append({k: v for k, v in x.items() if k not in ("nodes", "change_id")} | {"overlap": shared})
+        if found:
+            found.sort(key=lambda x: (x["date"], len(x["overlap"])), reverse=True)
+            return {"source": "openspec", "about": "finished OpenSpec changes and earlier reviews that touched the same code,"
+                                                   " newest first", "items": found[:limit], "total": len(found)}
+        return from_git(con, names, current, since, limit)
+    except Exception:   # a lead, never a reason for the plan or the review to fail
+        return {}
+
+
+def _ere(name: str) -> str:
+    """A name as a whole word in a POSIX extended regular expression (what `git log -G` reads)."""
+    body = "".join("\\" + ch if ch in ".^$*+?()[]{}|\\" else ch for ch in name)
+    return f"(^|[^A-Za-z0-9_$]){body}([^A-Za-z0-9_$]|$)"
+
+
+def _log(root: Path, since: Optional[str], paths: list[str], *extra: str) -> list[tuple[str, str, str, list[str]]]:
+    """(sha, date, subject, files) of the commits before `since` that changed `paths`, newest first; bulk commits
+    left out."""
+    from .coupling import _git
+    out = _git(root, "-c", "core.quotePath=false", "log", "--no-merges", "--full-diff", "--relative", "--name-only",
+               f"-n{MAX_COMMITS}", "--format=%x01%H%x02%cs%x02%s", *extra, since or "HEAD", "--", *paths, timeout=60)
+    found = []
+    for chunk in (out or b"").decode("utf-8", "replace").split("\x01")[1:]:
+        head, _, body = chunk.partition("\n")
+        sha, date, subject = (head.split("\x02") + ["", ""])[:3]
+        files = [f for f in body.splitlines() if f.strip()]
+        if len(files) <= BULK:
+            found.append((sha, date, subject.strip(), files))
+    return found
+
+
+def from_git(con, names, current: list[str], since: Optional[str] = None, limit: int = LIMIT) -> dict:
+    """The commits before the change that changed the code it touches: first those whose diff, in a changed
+    function's file, adds or removes a line naming that function (`git log -G`), then those that changed its files."""
+    by_repo: dict[str, set] = {}
+    fns: dict[str, list] = {}
+    for c in current:
+        row = names.by_id.get(c)
+        if row is None or not row["path"]:
+            continue
+        repo = c.split(":", 1)[0]
+        by_repo.setdefault(repo, set()).add(row["path"])
+        if row["kind"] in ("callable", "test", "type") and row["name"] not in ("<module>", "<top-level>") and len(row["name"]) >= 3:
+            fns.setdefault(repo, []).append((row["path"], row["name"], _label(names, c)))
+    commits: dict = {}
+    for repo, root in store.roots(con).items():
+        paths = sorted(by_repo.get(repo, set()))[:100]
+        if not paths or not Path(root).is_dir():
+            continue
+        mine = set(paths)
+        for sha, date, subject, files in _log(Path(root), since, paths):
+            shared = [f for f in files if f in mine]
+            if shared:
+                commits[(repo, sha)] = {"id": sha[:7], "kind": "commit", "title": subject, "date": date, "files": shared,
+                                        "names": [], **({"repo": repo} if len(by_repo) > 1 else {})}
+        for path, name, label in list(dict.fromkeys(fns.get(repo, [])))[:20]:   # a few calls, each on one file's history
+            for sha, *_ in _log(Path(root), since, [path], "-G", _ere(name)):
+                if (repo, sha) in commits and label not in commits[(repo, sha)]["names"]:
+                    commits[(repo, sha)]["names"].append(label)
+    if not commits:
+        return {}
+    ranked = sorted(commits.values(), key=lambda x: (len(x["names"]), len(x["files"]), x["date"]), reverse=True)
+    found = [{k: v for k, v in x.items() if k not in ("files", "names")}
+             | {"overlap": x["names"] or x["files"], "level": "function" if x["names"] else "file"} for x in ranked]
+    return {"source": "git", "about": "no OpenSpec history on this code; from git history: commits before it whose diff"
+                                      " names the same functions, then those that changed the same files (of the last"
+                                      f" {MAX_COMMITS} that touched them)",
+            "items": found[:limit], "total": len(found)}
+
+
+def lines(r: Optional[dict], header: str = "Earlier changes to this code") -> list[str]:
+    """The page's list, empty when there is nothing to say."""
+    if not r or not r.get("items"):
+        return []
+    L = ["", f"{header} ({r['about']}):", ""]
+    for x in r["items"]:
+        when = {"archived": "archived ", "checked": "checked ", "review": "reviewed "}.get(x["kind"], "") + (x["date"] or "undated")
+        what = ("Changed the same file:" if len(x["overlap"]) == 1 else "Changed the same files:") if x.get("level") == "file" \
+            else "Changed" if x["kind"] == "commit" else "Touched"
+        shared = ", ".join(f"`{n}`" for n in x["overlap"][:4]) + (f" and {len(x['overlap']) - 4} more" if len(x["overlap"]) > 4 else "")
+        title = x["title"].rstrip(".") + "." if x["title"] else ""
+        L.append(f"- `{x['id']}` ({when}): {title} {what} {shared}.".replace("  ", " "))
+    if r["total"] > len(r["items"]):
+        L.append(f"- and {r['total'] - len(r['items'])} more.")
+    return L

leyline/removal.py

@@ -0,0 +1,231 @@
+"""Tasks that take code away: "Remove `X`" and "Rename `X` to `Y`".
+
+`check` counts a task done when the code it names changed. For a removal that is too weak: `X` edited is not `X`
+removed, and `X` deleted while something still calls it is half a removal (the build or the run breaks there).
+So these two tasks are judged by what is left:
+
+    Remove `X`            proven when `X` is gone and nothing that called it still names it;
+                          partial when `X` is gone but a caller still calls it; contradicted when `X` still exists.
+    Rename `X` to `Y`     the same for `X`, and `Y` must be there too.
+
+Callers are those the baseline (the code as it was planned) linked to `X`: calls, and for a type or a file its
+uses and imports. A caller still calls `X` when it is still on the map and its text still has `X`'s name outside a
+comment and outside a string that is only the name (a key such as `row["X"]`). Only tasks written that way are judged so: "Remove a parameter from `X`" removes no `X`.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+from typing import Optional
+
+from . import diff, verdicts
+
+KIND_WORDS = (r"(?:the|an?|unused|dead|old|obsolete|legacy|deprecated|stale|now[- ]unused|function|method|class|type|"
+              r"field|property|constant|helper|file|module|interface|enum|struct|variable|member|attribute|route|"
+              r"endpoint|test)")
+REMOVE = re.compile(r"^\s*(?:remove|delete|drop)\s+(?:" + KIND_WORDS + r"\s+)*`", re.I)
+RENAME = re.compile(r"^\s*rename\s+(?:" + KIND_WORDS + r"\s+)*`([^`]+)`\s+(?:to|as|into)\s+(?:the\s+)?`([^`]+)`", re.I)
+USES = ("instantiates", "uses_type", "extends", "implements", "imports", "reads", "writes", "overrides")
+COMMENT = re.compile(r"^\s*(#|//|/\*|\*|--|')")
+
+
+def _is_path(written: str) -> bool:
+    from . import spec
+    return "/" in written or bool(spec.FILE_NAME.fullmatch(written))
+
+
+def _in_file(written: str) -> Optional[str]:
+    """`path/to/file.py: name` (or `file.py::name`): the name, without the file it is in."""
+    from . import spec
+    m = re.fullmatch(r"(?:" + spec.FILE_NAME.pattern + r")\s*::?\s*([A-Za-z_$][\w$.]*)(?:\(.*\))?", written.strip())
+    return m.group(1) if m else None
+
+
+def _leaf(written: str) -> str:
+    """The name a node of this written name has: `Engine.start` -> start; a file's path stays whole."""
+    w = re.sub(r"\(.*\)$", "", _in_file(written) or written.strip())
+    return w if _is_path(w) else w.split(".")[-1]
+
+
+def _word(name: str) -> re.Pattern:
+    return re.compile(r"(?<![\w$])" + re.escape(name) + r"(?![\w$])")
+
+
+def _targets(text: str) -> Optional[tuple[str, list[str], Optional[str]]]:
+    """("remove", [X, ...], None) or ("rename", [X], Y) for a task written as a removal or a rename, else None."""
+    m = RENAME.match(text)
+    if m:
+        return "rename", [m.group(1).strip()], m.group(2).strip()
+    if not REMOVE.match(text):
+        return None
+    from . import spec
+    cut = next((c.start() for c in spec.CLAUSE.finditer(text)), len(text))
+    head = text[:cut]
+    first = head.index("`")
+    close = head.find("`", first + 1)
+    if close < 0 or re.match(r"\s*['’]s\b", head[close + 1:]):   # "Remove `X`'s parameter": not X
+        return None
+    leads = [w for w, role in spec._roles(head) if role == "lead"]
+    return ("remove", leads, None) if leads else None
+
+
+class _Baseline:
+    """The code as it was planned, as kept in the change's snapshot."""
+
+    def __init__(self, con, cid: str):
+        snap = diff.snapshot_path(con, cid)
+        self.db = diff._open(snap) if snap.exists() else None
+
+    def row(self, i: str):
+        return self.db.execute("SELECT id, kind, name, parent_id, path FROM nodes WHERE id = ?", (i,)).fetchone()
+
+    def users(self, i: str) -> list[tuple[str, str]]:
+        """(user, how) for everything the baseline links to `i` or to something inside it."""
+        n = len(i) + 1
+        out = [(r[0], "calls") for r in self.db.execute(
+            "SELECT DISTINCT src_id FROM calls WHERE dst_id = ? OR substr(dst_id, 1, ?) IN (?, ?)", (i, n, i + ".", i + "("))]
+        out += [(r[0], "imports" if r[1] == "imports" else "uses") for r in self.db.execute(
+            f"SELECT DISTINCT src_id, kind FROM edges WHERE kind IN ({','.join('?' * len(USES))})"
+            f" AND (dst_id = ? OR substr(dst_id, 1, ?) IN (?, ?))", (*USES, i, n, i + ".", i + "("))]
+        return list(dict.fromkeys(out))
+
+    def close(self):
+        if self.db is not None:
+            self.db.close()
+
+
+def _text(con, i: str, cache: dict) -> Optional[str]:
+    """A node's own text as it is now, comment lines left out."""
+    r = con.execute("SELECT repo_id, path, kind, span_start, span_end FROM nodes WHERE id = ?", (i,)).fetchone()
+    if r is None or not r["path"]:
+        return None
+    key = (r["repo_id"], r["path"])
+    if key not in cache:
+        data = diff.source(con, *key)
+        cache[key] = data.decode("utf-8", errors="replace").split("\n") if data else None
+    lines = cache[key]
+    if lines is None:
+        return None
+    s, e = (1, len(lines)) if r["kind"] == "file" or not r["span_start"] else (r["span_start"], r["span_end"] or r["span_start"])
+    return "\n".join(ln for ln in lines[s - 1:e] if not COMMENT.match(ln))
+
+
+def _still_there(names, i: str, kind: str, bases: dict) -> bool:
+    """Whether the node is on the map now: by id, or by owner and name when only its parameters changed."""
+    if i in names.by_id:
+        return True
+    if kind != "callable":
+        return False
+    if "set" not in bases:
+        bases["set"] = {diff._base(x) for x, r in names.by_id.items() if r["kind"] == "callable"}
+    return diff._base(i) in bases["set"]
+
+
+def _callers(con, names, base: _Baseline, i: str, leaf: str, removed: set, cache: dict) -> list[tuple[str, str, bool]]:
+    """Code that used `i` before the change and still names it: (label, how, is a test), code first."""
+    from . import spec
+    name = Path(leaf).stem if _is_path(leaf) else leaf   # a file is named by its stem where it is imported
+    word = _word(name)
+    # A caller of the same name (a pytest fixture `child` that calls `engine.child()`) declares it: not a use.
+    own = re.compile(r"\b(?:def|function|fn|func|class|interface|struct|enum|sub)\s+" + re.escape(name) + r"(?![\w$])")
+    # A string that is just the name (a key: `{"about": ...}`, `row["about"]`) is not a use of it.
+    quoted = re.compile(r"([\"'`])" + re.escape(name) + r"\1")
+    out = []
+    for src, how in base.users(i):
+        if src == i or src.startswith((i + ".", i + "/", i + "(")) or src in removed or src not in names.by_id:
+            continue
+        text = _text(con, src, cache)
+        if text and word.search(quoted.sub(" ", own.sub(" ", text))):
+            out.append((spec._label(names, src), how, names.in_tests(src)))
+    return sorted(dict.fromkeys(out), key=lambda c: c[2])
+
+
+def _present(con, names, x_row, y: str) -> list[str]:
+    """The new name of a rename on the map, beside where the old one was: the node ids that answer to it."""
+    from . import spec
+    w = re.sub(r"\(.*\)$", "", _in_file(y) or y.strip())
+    if "/" in w or spec.FILE_NAME.fullmatch(w) and x_row["kind"] == "file":
+        return [f["id"] for f in names.file(w)]
+    parts = w.split(".")
+    owner = parts[-2] if len(parts) > 1 else None
+    out = []
+    for r in names.by_name.get(parts[-1], []):
+        if r["kind"] == "file" or (x_row["kind"] in ("callable", "field", "type") and r["kind"] != x_row["kind"]):
+            continue
+        parent = names.by_id.get(r["parent_id"])
+        if r["parent_id"] == x_row["parent_id"] or r["path"] == x_row["path"] or (owner and parent is not None and parent["name"] == owner):
+            out.append(r["id"])
+    return out
+
+
+def _who(callers: list[tuple[str, str, bool]]) -> str:
+    """"parse still calls it", "documentXml, OfferChanges and 3 tests still call it"."""
+    from . import spec
+    code = [c for c, _, test in callers if not test]
+    tests = [c for c, _, test in callers if test]
+    if not code and len(tests) <= 3:   # only tests: name them
+        code, tests = tests, []
+    items = code[:3] + ([f"{len(code) - 3} more"] if len(code) > 3 else []) + ([spec._n(len(tests), "test")] if tests else [])
+    hows = {h for _, h, _ in callers}
+    verb = "calls" if hows == {"calls"} else "imports" if hows == {"imports"} else "uses"
+    one = len(callers) == 1
+    return f"{spec._and(items)} still {verb if one else verb[:-1]} it"
+
+
+def check(con, cid: str, row, names, touched: set, removed: set) -> Optional[dict]:
+    """A removal or rename task judged by what is left: {state, verdict, why, missing, made}, or None when the task is not
+    one, or when nothing changed at all (the usual reading says so)."""
+    if row is None or row["action"] not in ("remove", "rename") or not (touched or removed):
+        return None
+    found = _targets(row["text"])
+    ids = json.loads(row["nodes"] or "[]")
+    if not found or not ids:
+        return None
+    kind, written, new = found
+    base = _Baseline(con, cid)
+    if base.db is None:
+        return None
+    try:
+        rows = {i: base.row(i) for i in ids}
+        cache, bases, judged, made = {}, {}, [], []
+        for w in written:
+            leaf = _leaf(w)
+            mine = [i for i in ids if rows[i] is not None and (rows[i]["name"] == leaf or rows[i]["kind"] == "file"
+                                                                and (rows[i]["path"] or "").endswith(leaf.lstrip("./")))]
+            if not mine:
+                continue
+            here = [i for i in mine if _still_there(names, i, rows[i]["kind"], bases)]
+            if here:
+                edited = any(diff._base(t) == diff._base(i) for i in here for t in touched)
+                judged.append((verdicts.CONTRADICTED, f"`{w}` still exists" + ("; it was edited, not removed" if edited and kind == "remove"
+                                                                                 else ""), f"{w} still exists"))
+                continue
+            if new is not None:
+                there = _present(con, names, rows[mine[0]], new)
+                made += there
+                if not there:
+                    judged.append((verdicts.CONTRADICTED, f"`{w}` is gone, but `{new}` is not on the map", f"{new}"))
+                    continue
+            callers = [c for i in mine for c in _callers(con, names, base, i, leaf, removed, cache)]
+            callers = list(dict.fromkeys(callers))
+            if callers:
+                judged.append((verdicts.PARTIAL, f"`{w}` is gone but {_who(callers)}",
+                               f"{callers[0][0]} still {'calls' if callers[0][1] == 'calls' else 'uses'} {w}"))
+            else:
+                judged.append((verdicts.PROVEN, f"`{w}` is gone" + (f" and `{new}` is there" if new else "")
+                               + ", and nothing still calls it", ""))
+    finally:
+        base.close()
+    if not judged:
+        return None
+    rank = (verdicts.CONTRADICTED, verdicts.PARTIAL, verdicts.PROVEN)
+    worst = min((v for v, _, _ in judged), key=rank.index)
+    if worst == verdicts.PROVEN:
+        why = "; ".join(w for _, w, _ in judged)
+    else:
+        why = "; ".join(w for v, w, _ in judged if v != verdicts.PROVEN)
+    return {"state": {verdicts.CONTRADICTED: "not done", verdicts.PARTIAL: "partly"}.get(worst, "done"),
+            "verdict": worst, "why": why, "missing": [m for _, _, m in judged if m],
+            "made": made}   # the new name of a rename: what the task added, not an edit outside the spec