workflow-toolkit 1.0.1

package/.agents/skills/wtk-deep-review/scripts/graphify_context.py

@@ -0,0 +1,75 @@
+"""Conditional Graphify context preparation for Deep Review."""
+
+from __future__ import annotations
+
+import hashlib
+import sys
+from pathlib import Path
+from typing import Any
+
+RI_SCRIPTS = Path(__file__).resolve().parents[2] / "wtk-config" / "scripts"
+if str(RI_SCRIPTS) not in sys.path:
+    sys.path.insert(0, str(RI_SCRIPTS))
+
+import repository_intelligence as ri  # noqa: E402
+
+
+def question_hash(question: str) -> str:
+    return hashlib.sha256(question.encode("utf-8")).hexdigest()
+
+
+def _fallback(path: Path, digest: str, reason: str) -> dict[str, str]:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        "\n".join([
+            "# Graphify context",
+            "",
+            "status: degraded",
+            f"question_hash: {digest}",
+            f"reason: {reason}",
+            "",
+            "Graphify context is unavailable; use targeted repository inspection.",
+        ]) + "\n",
+        encoding="utf-8",
+    )
+    return {"status": "degraded", "path": str(path), "question_hash": digest, "reason": reason}
+
+
+def _result_error(error: Exception) -> str:
+    if isinstance(error, ri.IntelligenceError):
+        return ri._redact(error.reason)
+    return "Graphify query failed"
+
+
+def prepare_graphify_context(repo: Path, out: Path, question: str) -> dict[str, str]:
+    """Run one bounded Graphify question and persist only its content-safe hash."""
+    path = out / "graphify-context.md"
+    digest = question_hash(question)
+    try:
+        result: Any = ri._run_context(repo, "graphify", "query", [question])
+    except Exception as error:  # adapter converts expected tool failures to IntelligenceError
+        return _fallback(path, digest, _result_error(error))
+    if isinstance(result, dict) and result.get("status") == "degraded":
+        return _fallback(path, digest, ri._redact(str(result.get("reason") or "Graphify query failed")))
+    context = str(result.get("context", "")).strip() if isinstance(result, dict) else ""
+    if not context:
+        return _fallback(path, digest, "Graphify returned insufficient context")
+    status = str(result.get("status", "ready")) if isinstance(result, dict) else "ready"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        "\n".join([
+            "# Graphify context",
+            "",
+            f"status: {status}",
+            f"question_hash: {digest}",
+            "",
+            "Use this bounded architecture context as orientation; verify every claim against the checkout.",
+            "",
+            "## Architecture context",
+            "```text",
+            context[:12000],
+            "```",
+        ]) + "\n",
+        encoding="utf-8",
+    )
+    return {"status": status, "path": str(path), "question_hash": digest}

package/.agents/skills/wtk-deep-review/scripts/merge_findings.py

@@ -0,0 +1,313 @@
+#!/usr/bin/env python3
+"""Deep-review finding merger (bootstrap helper; writes only under --out).
+
+Mechanically folds every reviewer/sweep output into the canonical ledger —
+no agents involved. Collects defects, advisories, suppressions, and coverage
+from jobs.json outputs (validating each against the schema), merges duplicates
+by identical fingerprint only, and reconciles against any prior state.json ledger: new /
+duplicate (still open from a prior round) / suppressed (dismissed before;
+never re-raised) — plus the resolved sweep for prior findings the fix
+removed. Emits findings.json, the single input render_review.py consumes.
+
+Exit codes: 0 ok, 1 missing/invalid outputs.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from collections import Counter, defaultdict
+from pathlib import Path
+
+sys.dont_write_bytecode = True  # keep the tracked skill tree free of __pycache__
+
+from _common import (
+    SEVERITY_RANK,
+    fingerprint,
+    hunk_text,
+    load_jobs,
+    read_json,
+    repo_root,
+    validate_job_output,
+    write_json,
+)
+
+
+class UnionFind:
+    def __init__(self, values: list[str]) -> None:
+        self.parent = {value: value for value in values}
+
+    def find(self, value: str) -> str:
+        parent = self.parent[value]
+        if parent != value:
+            self.parent[value] = self.find(parent)
+        return self.parent[value]
+
+    def union(self, left: str, right: str) -> None:
+        left_root, right_root = self.find(left), self.find(right)
+        if left_root != right_root:
+            self.parent[right_root] = left_root
+
+
+def unique(values: list) -> list:
+    seen, result = set(), []
+    for value in values:
+        if value not in seen:
+            seen.add(value)
+            result.append(value)
+    return result
+
+
+def anchor(finding: dict) -> str:
+    end_line = finding.get("end_line") or finding["line"]
+    suffix = str(finding["line"]) if end_line == finding["line"] else f"{finding['line']}-{end_line}"
+    return f"{finding['file']}:{suffix}"
+
+
+def collect(repo: Path, out: Path) -> dict[str, list[dict]]:
+    results: dict[str, list[dict]] = {
+        "defects": [], "advisories": [], "suppressions": [],
+        "hunk_coverage": [], "rule_coverage": [], "dispositions": [],
+    }
+    for job in load_jobs(out / "jobs.json"):
+        try:
+            validate_job_output(repo, out, job)
+        except ValueError as error:
+            raise RuntimeError(f"reviewer output invalid — {error}") from error
+        payload = read_json(repo / job["output"])
+        for key, result_kind, prefix in (
+            ("defects", "defect", "RD"), ("advisories", "advisory", "RA")
+        ):
+            for item in payload[key]:
+                decorated = {"result_kind": result_kind, **item}
+                results[key].append({
+                    "raw_id": f"{prefix}{len(results[key]) + 1:04d}",
+                    "source_job": job["label"],
+                    "fingerprint": fingerprint(decorated),
+                    **decorated,
+                })
+        for item in payload.get("suppressions", []):
+            results["suppressions"].append({
+                "source_job": job["label"], "lane": job["lane"], **item,
+            })
+        for item in payload["coverage"]["hunks"]:
+            results["hunk_coverage"].append({
+                "source_job": job["label"], "lane": job["lane"], **item,
+            })
+        for item in payload["coverage"].get("rules", []):
+            results["rule_coverage"].append({
+                "source_job": job["label"], "lane": job["lane"], **item,
+            })
+        for item in payload.get("prior_findings", []):
+            results["dispositions"].append({"source_job": job["label"], **item})
+    return results
+
+
+def group_duplicates(findings: list[dict]) -> list[list[dict]]:
+    """Union identical fingerprints only; distinct defects never merge."""
+    uf = UnionFind([finding["raw_id"] for finding in findings])
+    by_fingerprint: dict[str, list[dict]] = {}
+    for finding in findings:
+        by_fingerprint.setdefault(finding["fingerprint"], []).append(finding)
+    for members in by_fingerprint.values():
+        for member in members[1:]:
+            uf.union(members[0]["raw_id"], member["raw_id"])
+    grouped: dict[str, list[dict]] = {}
+    for finding in findings:
+        grouped.setdefault(uf.find(finding["raw_id"]), []).append(finding)
+    return list(grouped.values())
+
+
+def merge_group(members: list[dict]) -> dict:
+    ordered = sorted(
+        members, key=lambda f: (-SEVERITY_RANK[f["severity"]], f["line"], f["raw_id"])
+    )
+    canonical = ordered[0]
+    return {
+        **canonical,
+        "raw_ids": [m["raw_id"] for m in ordered],
+        "source_jobs": unique([m["source_job"] for m in ordered]),
+        "rule_ids": unique([rule_id for m in ordered for rule_id in (m.get("rule_ids") or [])]),
+        "also_applies": unique([
+            *(canonical.get("also_applies") or []),
+            *[anchor(m) for m in ordered[1:]],
+            *[target for m in ordered for target in (m.get("also_applies") or [])],
+        ]),
+        "evidence": unique([e for m in ordered for e in m.get("evidence", [])]),
+    }
+
+
+def raw_ledger_entries(members: list[dict], merged: dict) -> list[dict]:
+    entries = []
+    for member in members:
+        entry = {
+            "raw_id": member["raw_id"], "source_job": member["source_job"],
+            "fingerprint": member["fingerprint"], "file": member["file"],
+            "line": member["line"], "severity": member["severity"],
+            "title": member["title"], "result_kind": member["result_kind"],
+        }
+        if member["raw_id"] != merged["raw_ids"][0]:
+            entry["status"] = "merged"
+            entry["duplicate_of"] = merged["fingerprint"]
+        else:
+            entry["status"] = "canonical" if len(members) > 1 else "unique"
+        entries.append(entry)
+    return entries
+
+
+def reconcile(canonical: list[dict], found_fps: set[str], prior_state: dict | None,
+              dispositions: list[dict]) -> dict:
+    ledger = (prior_state or {}).get("ledger", {})
+    for finding in canonical:
+        row = ledger.get(finding["fingerprint"])
+        if row is None or row.get("status") == "resolved":
+            finding["round_status"] = "new"
+        elif row["status"] == "open":
+            finding["round_status"] = "duplicate"
+            finding["first_round"] = row.get("round")
+        else:  # dismissed — overruled before; never re-raise
+            finding["round_status"] = "suppressed"
+            finding["suppressed_as"] = row["status"]
+    # A prior open finding is resolved only by an explicit reviewer disposition;
+    # absence from the new output never means fixed.
+    resolved_fps = {d["fingerprint"] for d in dispositions if d["status"] == "resolved"}
+    resolved, still_open = [], []
+    for fp, row in ledger.items():
+        if row.get("status") != "open" or fp in found_fps:
+            continue
+        (resolved if fp in resolved_fps else still_open).append(fp)
+    return {
+        "resolved": sorted(resolved),
+        "still_open_unreviewed": sorted(still_open),
+        "prior_rounds": len((prior_state or {}).get("rounds", [])),
+    }
+
+
+HUNK_RE = re.compile(r"^(new|old):(\d+)-(\d+)$")
+
+
+def hunk_lines(file: str, hunk: str) -> Counter:
+    match = HUNK_RE.fullmatch(hunk)
+    if match is None:
+        raise RuntimeError(f"invalid canonical hunk {file}:{hunk}")
+    side, start, end = match.group(1), int(match.group(2)), int(match.group(3))
+    if end < start:
+        raise RuntimeError(f"invalid descending hunk {file}:{hunk}")
+    return Counter((file, side, line) for line in range(start, end + 1))
+
+
+def coverage_ledger(manifest: dict, collected: dict[str, list[dict]]) -> dict:
+    expected = Counter()
+    for file in manifest["files"]:
+        if file["disposition"] != "selected":
+            continue
+        for hunk in file["hunks"]:
+            expected += hunk_lines(file["path"], hunk_text(hunk))
+
+    lane_stats = {}
+    for lane in ("defect",):
+        actual = Counter()
+        rows = [row for row in collected["hunk_coverage"] if row["lane"] == lane]
+        for row in rows:
+            actual += hunk_lines(row["file"], row["hunk"])
+        missing, extra = expected - actual, actual - expected
+        if missing or extra:
+            raise RuntimeError(
+                f"{lane} coverage incomplete: missing_lines={sum(missing.values())} "
+                f"duplicated_or_extra_lines={sum(extra.values())}"
+            )
+        lane_stats[lane] = {
+            "rows": len(rows), "covered_lines": sum(actual.values()), "complete": True,
+        }
+
+    rule_status = defaultdict(Counter)
+    for row in collected["rule_coverage"]:
+        rule_status[row["rule_id"]][row["status"]] += 1
+    return {
+        "hunks": collected["hunk_coverage"],
+        "rules": collected["rule_coverage"],
+        "summary": {
+            "selected_hunk_lines": sum(expected.values()),
+            "lanes": lane_stats,
+            "rules": {rule: dict(sorted(counts.items())) for rule, counts in sorted(rule_status.items())},
+        },
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--out", required=True)
+    args = parser.parse_args()
+    repo = repo_root()
+    out = Path(args.out).resolve()
+    try:
+        manifest = read_json(out / "manifest.json")
+        collected = collect(repo, out)
+        coverage = coverage_ledger(manifest, collected)
+    except RuntimeError as error:
+        sys.stderr.write(f"{error}\n")
+        return 1
+
+    canonical_by_kind: dict[str, list[dict]] = {"defects": [], "advisories": []}
+    raw_ledger = []
+    for key in ("defects", "advisories"):
+        for members in group_duplicates(collected[key]):
+            merged = merge_group(members)
+            canonical_by_kind[key].append(merged)
+            raw_ledger.extend(raw_ledger_entries(members, merged))
+        canonical_by_kind[key].sort(key=lambda f: (f["file"], f["line"], f["raw_ids"][0]))
+    raw_ledger.sort(key=lambda item: item["raw_id"])
+
+    canonical_results = [*canonical_by_kind["defects"], *canonical_by_kind["advisories"]]
+
+    prior_state = read_json(out / "state.json") if (out / "state.json").is_file() else None
+    found_fps = {finding["fingerprint"] for finding in canonical_results}
+    reconciliation = reconcile(canonical_results, found_fps, prior_state, collected["dispositions"])
+
+    raw_count = len(collected["defects"]) + len(collected["advisories"])
+    canonical_count = len(canonical_results)
+    suppression_reasons = Counter(item["reason"] for item in collected["suppressions"])
+    review_stats = {
+        "candidates": raw_count + len(collected["suppressions"]),
+        "reported": raw_count,
+        "suppressed": len(collected["suppressions"]),
+        "suppression_reasons": dict(sorted(suppression_reasons.items())),
+        "raw_defects": len(collected["defects"]),
+        "raw_advisories": len(collected["advisories"]),
+        "canonical_defects": len(canonical_by_kind["defects"]),
+        "canonical_advisories": len(canonical_by_kind["advisories"]),
+        "coverage": coverage["summary"],
+    }
+
+    payload = {
+        "source_snapshot": manifest.get("worktree_snapshot"),
+        "summary": {
+            "raw": raw_count,
+            "canonical": canonical_count,
+            "merged_raw": raw_count - canonical_count,
+            "round_status": dict(sorted(Counter(f["round_status"] for f in canonical_results).items())),
+            "defect_severity": dict(sorted(Counter(f["severity"] for f in canonical_by_kind["defects"]).items())),
+            "advisory_category": dict(sorted(Counter(f["category"] for f in canonical_by_kind["advisories"]).items())),
+        },
+        "findings": canonical_by_kind["defects"],
+        "advisories": canonical_by_kind["advisories"],
+        "suppressions": collected["suppressions"],
+        "dispositions": collected["dispositions"],
+        "coverage": coverage,
+        "review_stats": review_stats,
+        "raw_ledger": raw_ledger,
+        "reconciliation": reconciliation,
+    }
+    write_json(out / "findings.json", payload)
+    write_json(out / "review-stats.json", review_stats)
+    print(f"findings ledger -> {out / 'findings.json'}")
+    print(f"review stats -> {out / 'review-stats.json'}")
+    print(json.dumps(payload["summary"], sort_keys=True))
+    print(json.dumps(reconciliation, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/.agents/skills/wtk-deep-review/scripts/render_html.py

@@ -0,0 +1,240 @@
+#!/usr/bin/env python3
+"""Deep-review HTML report generator (bootstrap helper; writes only under --out).
+
+Hydrates assets/REVIEW_UI.html — the fixed, self-contained report UI — with the
+round's artifacts: defects/advisories/suppressions/coverage from findings.json
+and manifest.json (required), plus state.json, walkthrough.md, rules.json,
+review.md and archived rounds when present. Emits
+<out>/review.html, the human-facing view of the review; agents keep consuming
+the JSON artifacts. Cheap and idempotent — re-run it after merge_findings.py
+and after render_review.py so the open dashboard (which auto-reloads) always
+shows the current round. Before render_review.py has run, the verdict renders
+as a neutral "round in progress" state.
+
+Exit codes: 0 ok, 1 missing/invalid inputs.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+import webbrowser
+from datetime import datetime, timezone
+from pathlib import Path
+
+sys.dont_write_bytecode = True  # keep the tracked skill tree free of __pycache__
+
+from _common import ASSETS_DIR, read_json, rel, repo_root
+from render_review import line_range, one_line, repair_plan
+
+TEMPLATE = ASSETS_DIR / "REVIEW_UI.html"
+PLACEHOLDER = "__DEEP_REVIEW_DATA__"
+
+
+def read_optional_json(path: Path):
+    return read_json(path) if path.is_file() else None
+
+
+def read_optional_text(path: Path) -> str | None:
+    return path.read_text(encoding="utf-8") if path.is_file() else None
+
+
+def ai_prompt(finding: dict) -> str | None:
+    """The same prompt render_review.py embeds in review.md, as copyable text."""
+    if finding.get("result_kind") != "defect" or finding["severity"] not in {"critical", "major"}:
+        return None
+    suggestion = one_line(finding.get("suggestion") or "")
+    remediation = suggestion or (
+        "correct the failure mode described in the finding at the owning layer"
+    )
+    rule_ids = ", ".join(finding.get("rule_ids") or []) or "review evidence"
+    return "\n".join([
+        "Verify this finding against the current code and fix it only if still valid.",
+        f"In {finding['file']} around lines {line_range(finding)}, {remediation}",
+        f"Reference anchor: {finding['file']}:{finding['line']}; rules: {rule_ids}.",
+    ])
+
+
+def verdict_for(state: dict | None, round_n: int, review_md: str | None) -> tuple[str, str | None]:
+    """Verdict from the round's state entry; rationale from review.md's header."""
+    verdict = "PENDING"
+    for entry in (state or {}).get("rounds", []):
+        if entry.get("n") == round_n:
+            verdict = entry.get("verdict", "PENDING")
+    rationale = None
+    if review_md:
+        match = re.search(r"^\*\*Verdict: (\w+)\*\* — (.+)$", review_md, re.M)
+        if match and match.group(1) == verdict:
+            rationale = match.group(2).strip()
+    return verdict, rationale
+
+
+def round_stats(ledger: dict | None) -> dict | None:
+    """Open-finding counts from a findings.json payload (live or archived)."""
+    if not ledger:
+        return None
+    open_findings = [
+        f for f in [*ledger.get("findings", []), *ledger.get("advisories", [])]
+        if f.get("round_status") in {"new", "duplicate"}
+    ]
+    defects = [f for f in open_findings if f.get("result_kind") == "defect"]
+    return {
+        "open": len(open_findings),
+        "critical": sum(1 for f in defects if f["severity"] == "critical"),
+        "major": sum(1 for f in defects if f["severity"] == "major"),
+        "advisories": sum(1 for f in open_findings if f.get("result_kind") == "advisory"),
+    }
+
+
+def rounds_timeline(out: Path, state: dict | None, manifest: dict,
+                    live_ledger: dict, verdict: str) -> list[dict]:
+    current_n = manifest["round"]
+    rounds = []
+    for entry in (state or {}).get("rounds", []):
+        n = entry.get("n")
+        ledger = live_ledger if n == current_n else read_optional_json(
+            out / "rounds" / f"round-{n}" / "findings.json"
+        )
+        rounds.append({
+            "n": n, "base": entry.get("base"), "head": entry.get("head"),
+            "verdict": entry.get("verdict"), "reviewed_at": entry.get("reviewed_at"),
+            "current": n == current_n, "stats": round_stats(ledger),
+        })
+    if not any(r["current"] for r in rounds):  # render_review has not run yet
+        rounds.append({
+            "n": current_n, "base": manifest.get("base"), "head": manifest.get("head"),
+            "verdict": verdict, "reviewed_at": None, "current": True,
+            "stats": round_stats(live_ledger),
+        })
+    return sorted(rounds, key=lambda r: r["n"])
+
+
+def ledger_rows(state: dict | None, fingerprints: list[str]) -> list[dict]:
+    ledger = (state or {}).get("ledger", {})
+    rows = []
+    for fp in fingerprints:
+        row = ledger.get(fp) or {}
+        rows.append({
+            "fingerprint": fp, "file": row.get("file", "?"),
+            "title": row.get("title", fp), "severity": row.get("severity", "minor"),
+            "round": row.get("round"), "resolved_in": row.get("resolved_in"),
+        })
+    return rows
+
+
+def dismissed_rows(state: dict | None) -> list[dict]:
+    ledger = (state or {}).get("ledger", {})
+    return [
+        {"fingerprint": fp, "file": row.get("file", "?"), "title": row.get("title", fp),
+         "severity": row.get("severity", "minor"), "round": row.get("round")}
+        for fp, row in sorted(ledger.items())
+        if row.get("status") == "dismissed"
+    ]
+
+
+def build_payload(repo: Path, out: Path) -> dict:
+    manifest = read_json(out / "manifest.json")
+    try:
+        ledger = read_json(out / "findings.json")
+    except RuntimeError as error:
+        raise RuntimeError(f"{error} — run merge_findings.py first") from error
+    state = read_optional_json(out / "state.json")
+    rules = read_optional_json(out / "rules.json") or {"rules": []}
+    rules_by_id = {rule["id"]: rule for rule in rules["rules"]}
+    review_md = read_optional_text(out / "review.md")
+    verdict, rationale = verdict_for(state, manifest["round"], review_md)
+
+    findings = []
+    for finding in [*ledger.get("findings", []), *ledger.get("advisories", [])]:
+        resolved_rules = [
+            {"id": rid, "source": rules_by_id[rid]["source"],
+             "guideline": rules_by_id[rid]["guideline"]}
+            for rid in (finding.get("rule_ids") or []) if rid in rules_by_id
+        ]
+        findings.append({
+            **finding,
+            "rules": resolved_rules,
+            "ai_prompt": ai_prompt(finding),
+            "repair_plan": repair_plan(finding),
+        })
+
+    reconciliation = ledger.get("reconciliation", {})
+    return {
+        "schema_version": 2,
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "target": manifest["target"],
+        "pr": manifest.get("pr"),
+        "mode": manifest.get("mode"),
+        "round": manifest["round"],
+        "base": manifest.get("base"),
+        "head": manifest.get("head"),
+        "counts": manifest.get("counts", {}),
+        "out_dir": rel(out, repo),
+        "verdict": verdict,
+        "verdict_rationale": rationale,
+        "summary": ledger.get("summary", {}),
+        "findings": findings,
+        "suppressions": ledger.get("suppressions", []),
+        "coverage": ledger.get("coverage", {}),
+        "review_stats": ledger.get("review_stats", {}),
+        "resolved": ledger_rows(state, reconciliation.get("resolved", [])),
+        "unreviewed_open": ledger_rows(state, reconciliation.get("still_open_unreviewed", [])),
+        "dismissed": dismissed_rows(state),
+        "rounds": rounds_timeline(out, state, manifest, ledger, verdict),
+        "walkthrough": read_optional_text(out / "walkthrough.md"),
+    }
+
+
+def hydrate(payload: dict) -> str:
+    template = TEMPLATE.read_text(encoding="utf-8")
+    occurrences = template.count(PLACEHOLDER)
+    if occurrences != 1:
+        raise RuntimeError(
+            f"template {TEMPLATE} must contain the data placeholder exactly once "
+            f"(found {occurrences})"
+        )
+    # Escape sequences that would let JSON text break out of the <script> data
+    # block: </ (closes the tag) and <!-- (opens an HTML comment-escaped state).
+    data = (
+        json.dumps(payload, ensure_ascii=False)
+        .replace("</", "<\\/")
+        .replace("<!--", "<\\u0021--")
+    )
+    return template.replace(PLACEHOLDER, data, 1)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--out", required=True)
+    parser.add_argument("--open", action="store_true", dest="open_browser",
+                        help="open the generated report in the default browser")
+    args = parser.parse_args()
+    try:
+        repo = repo_root()
+        out = Path(args.out).resolve()
+        payload = build_payload(repo, out)
+        (out / "review.html").write_text(hydrate(payload), encoding="utf-8")
+    except RuntimeError as error:
+        sys.stderr.write(f"{error}\n")
+        return 1
+
+    open_findings = [f for f in payload["findings"]
+                     if f.get("round_status") in {"new", "duplicate"}]
+    defects = [f for f in open_findings if f.get("result_kind") == "defect"]
+    advisories = [f for f in open_findings if f.get("result_kind") == "advisory"]
+    severities = {s: sum(1 for f in open_findings if f["severity"] == s)
+                  for s in ("critical", "major", "minor", "trivial")}
+    print(f"report -> {out / 'review.html'}")
+    print(f"verdict={payload['verdict']} defects={len(defects)} advisories={len(advisories)} "
+          f"(critical={severities['critical']} major={severities['major']} "
+          f"minor={severities['minor']} trivial={severities['trivial']}) "
+          f"resolved={len(payload['resolved'])} rounds={len(payload['rounds'])}")
+    if args.open_browser:
+        webbrowser.open((out / "review.html").as_uri())
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())