syncade 0.7.3__tar.gz → 0.7.6__tar.gz

{syncade-0.7.3/src/syncade.egg-info → syncade-0.7.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syncade
-Version: 0.7.3
+Version: 0.7.6
 Summary: External blind multi-judge review orchestrator for AI-assisted coding
 Author-email: Syncade <build@syncade.ai>
 License-Expression: Apache-2.0

{syncade-0.7.3 → syncade-0.7.6}/pyproject.toml

@@ -9,7 +9,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "syncade"
-version = "0.7.3"
+version = "0.7.6"
 description = "External blind multi-judge review orchestrator for AI-assisted coding"
 readme = "README.md"
 requires-python = ">=3.11"

{syncade-0.7.3 → syncade-0.7.6}/src/syncade/__init__.py

@@ -1,3 +1,3 @@
 """Syncade — external blind multi-judge review orchestrator."""
 
-__version__ = "0.7.3"
+__version__ = "0.7.6"

{syncade-0.7.3 → syncade-0.7.6}/src/syncade/cli/metrics_mode.py

@@ -255,11 +255,21 @@ def render_report(conn: sqlite3.Connection, last_n: int | None = None) -> str:
     ).fetchone()
     actor_rows = _actor_spend_rows(conn)
     incomplete_tokens = _cost_incomplete_tokens(conn)
+    manifest_only, unknown_only = conn.execute(
+        "SELECT "
+        "COALESCE(SUM(CASE WHEN counts_source='manifest' THEN 1 ELSE 0 END), 0), "
+        "COALESCE(SUM(CASE WHEN counts_source='unknown' THEN 1 ELSE 0 END), 0) "
+        "FROM rounds "
+        "WHERE NOT (counts_source='manifest' AND panel_source='recorded' AND panel_size=0 "
+        "AND blockers=0 AND minors=0 AND nits=0 AND dismissed=0)"
+    ).fetchone()
+    finding_note = " (lower bounds: incomplete round evidence)" if unknown_only else ""
 
     lines = [
         f"syncade metrics — {runs} runs",
         f"  ship-rate:  {ship}/{runs} ({round(100 * ship / runs)}%)",
-        f"  findings:   {blockers} blockers, {minors} minors, {nits} nits, {dismissed} dismissed",
+        f"  findings:   {blockers} blockers, {minors} minors, {nits} nits, {dismissed} dismissed"
+        f"{finding_note}",
         f"  rounds:     {rounds} total",
         f"  handoffs:   {handoffs}    decisions: {decisions}",
         f"  producer:   committed={p_committed} stalled={p_stalled}"
@@ -322,7 +332,7 @@ def render_report(conn: sqlite3.Connection, last_n: int | None = None) -> str:
     # OUTSIDE the `if reviewer_rows` block on purpose. Nested inside it, a corpus where EVERY
     # panel is unknown printed no warning at all — the one corpus that most needs it, silent.
     # panel_source='unknown' means no manifest had a `reviewers` key for that round. This is
-    # independent of blockers_source: a manifest can record a blocker count without a reviewer
+    # independent of counts_source: a manifest can record finding counts without a reviewer
     # list, and a no-dispatch round (no_changes_to_review) has panel_source='recorded' and
     # panel_size=0 — explicitly empty, not unknown.
     unknown_rounds, total_rounds = conn.execute(
@@ -334,23 +344,17 @@ def render_report(conn: sqlite3.Connection, last_n: int | None = None) -> str:
             f"  {unknown_rounds} of {total_rounds} rounds record no reviewer panel "
             f"(no manifest evidence; excluded from consensus)"
         )
-    manifest_only, unknown_only = conn.execute(
-        "SELECT "
-        "COALESCE(SUM(CASE WHEN blockers_source='manifest' THEN 1 ELSE 0 END), 0), "
-        "COALESCE(SUM(CASE WHEN blockers_source='unknown' THEN 1 ELSE 0 END), 0) "
-        "FROM rounds "
-        "WHERE NOT (panel_source='recorded' AND panel_size=0 AND blockers=0)"
-    ).fetchone()
     if manifest_only:
         lines.append(
-            f"  {manifest_only} of {total_rounds} rounds have no synthesizer artifact; their "
-            f"blocker counts come from round manifests and carry no provenance"
+            f"  {manifest_only} of {total_rounds} rounds have finding counts from manifests "
+            f"but no usable synthesizer artifact evidence; no per-finding provenance is available"
         )
     if unknown_only:
         lines.append(
-            f"  {unknown_only} of {total_rounds} rounds have no blocker evidence "
-            f"(killed/interrupted before any artifact or manifest); "
-            f"excluded from the blocker curve"
+            f"  {unknown_only} of {total_rounds} rounds have no finding-count evidence "
+            f"(killed/interrupted before a usable artifact or complete manifest); "
+            f"top-line findings are lower bounds and these rounds are excluded from the "
+            f"blocker curve"
         )
 
     consensus = consensus_stats(conn)

{syncade-0.7.3 → syncade-0.7.6}/src/syncade/cli/update_mode.py

@@ -21,6 +21,7 @@ import site
 import subprocess
 import sys
 from dataclasses import dataclass
+from importlib.metadata import Distribution
 from pathlib import Path
 
 import syncade
@@ -29,9 +30,6 @@ from syncade.process import SubprocessError, run_subprocess
 from syncade.update_check import _parse, _text, manifest_once
 
 _UPGRADE_TIMEOUT = 300.0
-#: Reading one version string out of a fresh interpreter. Generous, because a cold venv
-#: import is slower than it looks; short, because we already hold the operator's terminal.
-_VERSION_TIMEOUT = 60.0
 #: How far up from ``syncade/__init__.py`` an install marker can sit. A venv layout is
 #: ``<root>/lib/python3.x/site-packages/syncade/__init__.py`` — five parents to the root; the
 #: extra headroom costs nothing and covers layouts that nest one deeper.
@@ -59,6 +57,21 @@ def _in_user_site() -> bool:
     return user_site in Path(syncade.__file__).resolve().parents
 
 
+def _scoped_dist_infos() -> list[Path]:
+    """The dist-info directories beside the package that supplied this process's code."""
+    try:
+        site_packages = Path(syncade.__file__).resolve().parent.parent
+        return sorted(
+            entry
+            for entry in site_packages.iterdir()
+            if entry.name.casefold().startswith("syncade-")
+            and entry.name.casefold().endswith(".dist-info")
+            and entry.is_dir()
+        )
+    except (OSError, RuntimeError, TypeError):
+        return []
+
+
 def _read_scoped_installer() -> str:
     """Read INSTALLER from the dist-info directory that BELONGS to this syncade install.
 
@@ -71,27 +84,44 @@ def _read_scoped_installer() -> str:
     is empty string — the same as not found.  First-match would misclassify in that state,
     which contradicts the PROVE-or-refuse posture the rest of this module maintains.
     """
-    site_packages = Path(syncade.__file__).resolve().parent.parent
     found: list[str] = []
-    try:
-        for entry in site_packages.iterdir():
-            if (
-                entry.name.startswith("syncade-")
-                and entry.name.endswith(".dist-info")
-                and entry.is_dir()
-            ):
-                try:
-                    found.append((entry / "INSTALLER").read_text(encoding="utf-8").strip())
-                except OSError:
-                    pass  # No INSTALLER file — this dist-info cannot prove anything.
-    except OSError:
-        pass
+    for entry in _scoped_dist_infos():
+        try:
+            found.append((entry / "INSTALLER").read_text(encoding="utf-8").strip())
+        except OSError:
+            pass  # No INSTALLER file — this dist-info cannot prove anything.
     if not found:
         return ""
     # Contradictory entries in a broken packaging state are not proof of anything.
     return found[0] if len(set(found)) == 1 else ""
 
 
+def _read_scoped_version() -> str | None:
+    """Read ``Version`` from this syncade install's one adjacent dist-info.
+
+    The package directory is already the authoritative identity: it supplied the code running
+    this function. Reading its sibling metadata after the package manager returns sees the new
+    on-disk version without resolving the name ``syncade`` through ``sys.path`` again. A missing,
+    malformed, or duplicate dist-info is ambiguous and therefore unverifiable, never first-match.
+    """
+    candidates = _scoped_dist_infos()
+    if len(candidates) != 1:
+        return None
+    try:
+        if not (candidates[0] / "METADATA").is_file():
+            return None
+        metadata = Distribution.at(candidates[0]).metadata
+        names = metadata.get_all("Name") or []
+        versions = metadata.get_all("Version") or []
+    except Exception:  # noqa: BLE001 — broken install metadata degrades to "unverifiable".
+        return None
+    if len(names) != 1 or names[0].strip().casefold() != "syncade":
+        return None
+    if len(versions) != 1:
+        return None
+    return versions[0].strip()
+
+
 def _pip_or_unknown(where: Path | None) -> InstallMethod:
     """``pip`` when the distribution records pip as its installer, else ``unknown``.
 
@@ -239,49 +269,14 @@ def _installed_version() -> str | None:
     """The version on disk NOW, or ``None`` when it cannot be established.
 
     It CANNOT be ``syncade.__version__``: this process imported that before the upgrade ran, so
-    it is by definition the old number. A fresh interpreter re-reads the metadata the upgrade
-    just rewrote, and ``sys.executable`` is the tool venv's own python under both uv and pipx —
-    precisely the environment that changed.
+    it is by definition the old number. The value is read from the dist-info tree that belongs
+    to this install, so the answer follows the package on disk instead of any ambient metadata
+    discovery or subprocess import state.
 
     ``None`` means "could not verify", which is deliberately NOT the same as "did not change":
     the caller must not turn an unreadable version into a failure report.
     """
-    try:
-        result = run_subprocess(
-            # `-I` (isolated) is load-bearing, not tidiness. Without it the probe inherits
-            # PYTHONPATH and the user site dir, so a `sitecustomize` on that path runs inside
-            # the answer and can emit stdout before OR after the version print.
-            # `-I` keeps the venv's own site-packages, so `importlib.metadata` still finds
-            # the install (verified) — but it does NOT suppress `sitecustomize.py` that lives
-            # in those site-packages. An atexit hook registered there (syncade ships such a
-            # shim for worktree imports) can append a version-shaped line AFTER the real one.
-            # `os._exit(0)` bypasses all atexit handlers: the process terminates immediately
-            # after `os.write`, so nothing can append to our stdout (reproduced: a hostile
-            # sitecustomize turned "0.7.0" into "0.7.0\n99.0.0" before this fix).
-            # `os.write` is used instead of `print` because `os._exit` skips stdio flushing;
-            # an unbuffered syscall guarantees the version byte reaches the pipe.
-            [
-                sys.executable,
-                "-I",
-                "-c",
-                "import importlib.metadata as m, os; "
-                "os.write(1, (m.version('syncade') + '\\n').encode()); "
-                "os._exit(0)",
-            ],
-            timeout=_VERSION_TIMEOUT,
-        )
-    except SubprocessError:
-        return None
-    if result.returncode != 0:
-        return None
-    raw = result.stdout.strip()
-    if not raw:
-        return None
-    # sitecustomize from PYTHONPATH (suppressed by -I) could emit noise before -c runs;
-    # the venv's own sitecustomize can still do so. Take the LAST line — atexit is now
-    # impossible (os._exit), so the last line is what os.write put there — and validate it
-    # parses as a version. Noise that accidentally ends in a dotted string still fails _parse.
-    candidate = raw.splitlines()[-1].strip()
+    candidate = _read_scoped_version()
     return candidate if _parse(candidate) is not None else None
 
 

{syncade-0.7.3 → syncade-0.7.6}/src/syncade/config.py

@@ -327,6 +327,11 @@ def _default_reviewers() -> list[ReviewerConfig]:
     #                  model="claude-opus-4-6", adversarial_lens=True)
 
 
+def _default_worktree_base() -> Path:
+    """Resolve the worktree default when a config instance is created."""
+    return DEFAULT_WORKTREE_BASE
+
+
 class SyncadeConfig(BaseModel):
     """Top-level ``.syncade/config.toml`` schema.
 
@@ -363,7 +368,7 @@ class SyncadeConfig(BaseModel):
     # ``[worktree]`` block — Q5); default reproduces worktree.DEFAULT_WORKTREE_BASE.
     # ``--worktree-base`` overrides per-invocation; threaded into the review run and doctor preview.
     worktree_base: Path = Field(
-        default=DEFAULT_WORKTREE_BASE,
+        default_factory=_default_worktree_base,
         description=(
             "Base directory under which each run's per-reviewer/producer/test git worktrees are "
             f"created (default ``{DEFAULT_WORKTREE_BASE}``). Overridable per-run with "

{syncade-0.7.3 → syncade-0.7.6}/src/syncade/metrics/aggregate.py

@@ -16,6 +16,7 @@ import sys
 from pathlib import Path
 
 from syncade.metrics.findings import (
+    read_finding_artifacts,
     read_findings,
     read_rounds,
 )
@@ -137,6 +138,9 @@ def _load_init(run_dir: Path) -> dict:
 def read_run(run_dir: Path | str) -> tuple[RunRow, list[ReviewerStatRow]] | None:
     """Map one run directory to a :class:`RunRow` + per-reviewer stats.
 
+    Finding totals on the returned row are provisional loop-manifest summaries. ``backfill()``
+    replaces the complete vector from normalized round evidence before persisting the row.
+
     Returns ``None`` when ``loop-manifest.json`` is present but unparseable — a
     *corrupt* run, which the caller skips with a warning rather than counting it as
     a bogus UNKNOWN run. A *missing* or *parseable-but-partial* manifest is still
@@ -510,7 +514,8 @@ def backfill(conn: sqlite3.Connection, runs_root: Path | str) -> None:
 
     Upserts every present run, refreshes each run's reviewer set (so a changed
     roster drops stale rows), and prunes runs no longer in ``.syncade/runs/`` — so
-    the DB stays a faithful derived view even after ``--gc`` slims runs.
+    the DB stays a faithful derived view even after ``--gc`` slims runs. This is the final
+    authority for persisted run totals; ``read_run()`` alone returns provisional summaries.
     """
     present: list[str] = []
     for d in _candidate_run_dirs(runs_root):
@@ -522,6 +527,15 @@ def backfill(conn: sqlite3.Connection, runs_root: Path | str) -> None:
             )
             continue
         row, stats = parsed
+        artifacts = read_finding_artifacts(d)
+        findings, provenance = read_findings(d, row.run_id, artifacts)
+        round_rows = read_rounds(d, row.run_id, artifacts)
+        row.blockers, row.minors, row.nits, row.dismissed = (
+            sum(r.blockers for r in round_rows),
+            sum(r.minors for r in round_rows),
+            sum(r.nits for r in round_rows),
+            sum(r.dismissed for r in round_rows),
+        )
         upsert_run(conn, row)
         conn.execute("DELETE FROM reviewer_stats WHERE run_id = ?", (row.run_id,))
         conn.execute("DELETE FROM actor_stats WHERE run_id = ?", (row.run_id,))
@@ -533,24 +547,13 @@ def backfill(conn: sqlite3.Connection, runs_root: Path | str) -> None:
         for stat in read_actor_stats(d):
             upsert_actor_stat(conn, stat)
 
-        findings, provenance = read_findings(d, row.run_id)
         for finding in findings:
             upsert_finding(conn, finding)
         for entry in provenance:
             upsert_finding_provenance(conn, entry)
 
-        # ONE derivation, no branch. `rounds` already resolved artifacts-vs-manifest per round
-        # and recorded which it used, so the run total is a sum rather than a choice between two
-        # counts that could disagree. What stood here was a reached-set supplement plus a
-        # conditional derive-or-preserve — three rounds of patching the same question, which is
-        # what the single authority replaces.
-        round_rows = read_rounds(d, row.run_id)
         for round_row in round_rows:
             upsert_round(conn, round_row)
-        conn.execute(
-            "UPDATE runs SET blockers = ? WHERE run_id = ?",
-            (sum(r.blockers for r in round_rows), row.run_id),
-        )
 
         present.append(row.run_id)
     _prune_absent(conn, present)

{syncade-0.7.3 → syncade-0.7.6}/src/syncade/metrics/findings.py

@@ -11,12 +11,9 @@ physical lines against a 600 ceiling; extraction there would have breached it on
 rebuild on schema drift exactly like ``runs``. The derived-view rule is intact: nothing here is
 the only copy of anything.
 
-**The count-agreement hazard is the reason this module has a public
-:func:`count_disagreements`.** ``runs.blockers`` sums each round manifest's
-``active_blocker_count``; these rows come from the synthesizer artifact. Two paths to one fact
-WILL drift, so the disagreement is measured and reported rather than assumed away — and the
-verdict on what to do about it is the caller's, because a hard failure would make one
-inconsistent legacy run poison a whole backfill.
+**The count-agreement hazard is the reason this module owns the per-round authority.** Every
+finding count travels as one vector with one recorded source; consumers sum those rows rather
+than choosing independently between artifacts and manifests.
 """
 
 from __future__ import annotations
@@ -27,6 +24,11 @@ from pathlib import Path
 from syncade.metrics.schema import FindingProvenanceRow, FindingRow, RoundRow
 
 _SYNTH_ARTIFACT = "synthesizer.parsed.json"
+_KNOWN_EMPTY_REASONS = {"no_changes_to_review", "producer_emptied_diff"}
+_KNOWN_FINDING_SEVERITIES = {"blocker", "minor", "nit"}
+_CountVector = tuple[int, int, int, int]
+_ArtifactEvidence = tuple[list[dict[str, object]], _CountVector]
+_RoundArtifacts = dict[int, tuple[Path, _ArtifactEvidence | None]]
 
 
 def round_dirs(run_dir: Path) -> list[tuple[int, Path]]:
@@ -54,8 +56,47 @@ def _text(value: object) -> str:
     return value if isinstance(value, str) else ""
 
 
+def _normalize_artifact(container: object) -> _ArtifactEvidence | None:
+    """One complete finding list and its count vector, or no artifact evidence."""
+    if not isinstance(container, dict):
+        return None
+    consolidated = container.get("consolidated_findings")
+    if not isinstance(consolidated, list):
+        return None
+    normalized: list[dict[str, object]] = []
+    active = {severity: 0 for severity in _KNOWN_FINDING_SEVERITIES}
+    dismissed = 0
+    for finding in consolidated:
+        if not isinstance(finding, dict):
+            return None
+        severity = finding.get("severity")
+        is_dismissed = finding.get("dismissed")
+        if not isinstance(severity, str) or severity not in active:
+            return None
+        if type(is_dismissed) is not bool:
+            return None
+        normalized.append(finding)
+        if is_dismissed:
+            dismissed += 1
+        else:
+            active[severity] += 1
+    return normalized, (active["blocker"], active["minor"], active["nit"], dismissed)
+
+
+def read_finding_artifacts(run_dir: Path | str) -> _RoundArtifacts:
+    """Parse and count each round's count-critical artifact exactly once."""
+    artifacts: _RoundArtifacts = {}
+    for round_index, round_dir in round_dirs(Path(run_dir)):
+        try:
+            data = json.loads((round_dir / _SYNTH_ARTIFACT).read_text(encoding="utf-8"))
+        except (OSError, ValueError):
+            data = None
+        artifacts[round_index] = (round_dir, _normalize_artifact(data))
+    return artifacts
+
+
 def read_findings(
-    run_dir: Path | str, run_id: str
+    run_dir: Path | str, run_id: str, artifacts: _RoundArtifacts
 ) -> tuple[list[FindingRow], list[FindingProvenanceRow]]:
     """Every consolidated finding in a run, with its provenance. Never raises.
 
@@ -71,26 +112,14 @@ def read_findings(
         _loop = {}
     _loop_rounds = _loop.get("rounds") if isinstance(_loop, dict) else None
 
-    for round_index, round_dir in round_dirs(run_dir):
+    for round_index, (round_dir, evidence) in sorted(artifacts.items()):
         # A reviewer absent from the round's PANEL cannot have raised a finding in it. Ghost
         # provenance inflates consensus, and the ratio is the number the whole feature exists
         # to report. An unrecorded panel (empty) cannot convict anyone, so it filters nothing.
         _panel, _ = _round_panel(_loop_rounds, round_dir, round_index)
-        try:
-            data = json.loads((round_dir / _SYNTH_ARTIFACT).read_text(encoding="utf-8"))
-        except (OSError, ValueError):
-            continue
-        if not isinstance(data, dict):
-            continue
-        consolidated = data.get("consolidated_findings")
-        if not isinstance(consolidated, list):
-            continue
-        # All-or-nothing: a partially malformed list degrades to 'manifest' in read_rounds().
-        # Persisting the valid-looking subset here would leave metrics.db with contradictory
-        # round/run counts versus findings/provenance rows — the count mismatch this whole
-        # table exists to prevent, reintroduced by the reader.
-        if not all(isinstance(f, dict) for f in consolidated):
+        if evidence is None:
             continue
+        consolidated, _counts = evidence
 
         for idx, finding in enumerate(consolidated):
             findings.append(
@@ -99,10 +128,7 @@ def read_findings(
                     round=round_index,
                     idx=idx,
                     severity=_text(finding.get("severity")),
-                    # `is True`, not truthiness: `dismissed="false"` is a TRUTHY string and
-                    # would mark an ACTIVE blocker dismissed, quietly shrinking every count
-                    # derived from it. Anything that is not a real boolean True is active.
-                    dismissed=1 if finding.get("dismissed") is True else 0,
+                    dismissed=1 if finding["dismissed"] else 0,
                     file=_text(finding.get("file")),
                     description=_text(finding.get("description")),
                 )
@@ -148,9 +174,9 @@ def _round_panel(loop_rounds: object, round_dir: Path, round_index: int) -> tupl
     like ``no_changes_to_review`` records ``reviewers: []``) and ``'unknown'`` when no
     manifest had the key and the panel composition cannot be determined.
 
-    Panel provenance is independent from blocker-count provenance: a manifest can carry an
+    Panel provenance is independent from finding-count provenance: a manifest can carry
     ``active_blocker_count`` without a ``reviewers`` list, giving
-    ``blockers_source='manifest'`` and ``panel_source='unknown'``.
+    ``counts_source='manifest'`` and ``panel_source='unknown'``.
     """
     names: set[str] = set()
     recorded = False
@@ -176,15 +202,27 @@ def _round_panel(loop_rounds: object, round_dir: Path, round_index: int) -> tupl
     return names, "recorded" if recorded else "unknown"
 
 
-def _synth_count(container: object) -> int | None:
-    """``synthesizer.active_blocker_count`` from a manifest-shaped dict, if it is a real int."""
+_COUNT_KEYS = (
+    "active_blocker_count",
+    "active_minor_count",
+    "active_nit_count",
+    "dismissed_count",
+)
+
+
+def _synth_counts(container: object) -> _CountVector | None:
+    """The complete synthesizer count vector from a manifest-shaped dict, if valid."""
     synth = container.get("synthesizer") if isinstance(container, dict) else None
-    count = synth.get("active_blocker_count") if isinstance(synth, dict) else None
-    return count if isinstance(count, int) and not isinstance(count, bool) else None
+    if not isinstance(synth, dict):
+        return None
+    values = tuple(synth.get(key) for key in _COUNT_KEYS)
+    if not all(type(value) is int and value >= 0 for value in values):
+        return None
+    return values
 
 
-def _manifest_blockers(round_dir: Path, loop_rounds: object, round_index: int) -> int | None:
-    """A manifest-recorded blocker count for this round, or ``None``.
+def _manifest_counts(round_dir: Path, loop_rounds: object, round_index: int) -> _CountVector | None:
+    """A complete manifest-recorded count vector for this round, or ``None``.
 
     BOTH manifests are consulted, in that order, for the same reason the round set is a union:
     either alone is incomplete. The round manifest exists for interrupted runs the loop manifest
@@ -196,24 +234,24 @@ def _manifest_blockers(round_dir: Path, loop_rounds: object, round_index: int) -
         data = json.loads((round_dir / _ROUND_MANIFEST).read_text(encoding="utf-8"))
     except (OSError, ValueError):
         data = None
-    count = _synth_count(data)
-    if count is not None:
-        return count
+    counts = _synth_counts(data)
+    if counts is not None:
+        return counts
     if isinstance(loop_rounds, list) and round_index < len(loop_rounds):
-        return _synth_count(loop_rounds[round_index])
+        return _synth_counts(loop_rounds[round_index])
     return None
 
 
-def read_rounds(run_dir: Path | str, run_id: str) -> list[RoundRow]:
+def read_rounds(run_dir: Path | str, run_id: str, artifacts: _RoundArtifacts) -> list[RoundRow]:
     """One row per round that happened — THE authority, replacing three disagreeing derivations.
 
-    Precedence for the blocker count is explicit and recorded, never inferred:
+    Precedence for the complete finding-count vector is explicit and recorded, never inferred:
 
     1. ``artifacts`` — the synthesizer artifact parsed and every entry was well-formed.
-    2. ``manifest`` — the artifact is missing or malformed but a round manifest recorded a
-       count. The round ran and found something; only the evidence of WHAT is gone.
+    2. ``manifest`` — the artifact is missing or malformed but a manifest recorded all four
+       counts. The round ran and found something; only the evidence of WHAT is gone.
     3. ``unknown`` — the round ran and nothing credible says what it found. Counted as a round,
-       contributing zero blockers, because inventing either number is worse.
+       contributing zeroes by convention, because inventing counts is worse.
 
     A partially-malformed artifact degrades to ``manifest``/``unknown`` rather than silently
     reporting the entries that happened to parse: dropping three of five findings and calling
@@ -229,7 +267,7 @@ def read_rounds(run_dir: Path | str, run_id: str) -> list[RoundRow]:
     # The union of BOTH kinds of evidence, because either alone is incomplete: a directory can
     # exist for a round the manifest never summarised (interrupted), and a manifest can prove a
     # round ran whose directory is absent. Taking one source was the mistake this table replaces.
-    on_disk = dict(round_dirs(run_dir))
+    on_disk = {index: entry[0] for index, entry in artifacts.items()}
     indices = set(on_disk)
     if isinstance(loop_rounds, list):
         indices |= set(range(len(loop_rounds)))
@@ -238,13 +276,31 @@ def read_rounds(run_dir: Path | str, run_id: str) -> list[RoundRow]:
     for round_index in sorted(indices):
         round_dir = on_disk.get(round_index, run_dir / f"round-{round_index}")
         panel, panel_source = _round_panel(loop_rounds, round_dir, round_index)
-        blockers, source = _round_blockers(round_dir, loop_rounds, round_index)
+        known_no_dispatch = (
+            isinstance(loop_rounds, list)
+            and round_index == len(loop_rounds) - 1
+            and isinstance(loop, dict)
+            and loop.get("termination_reason") in _KNOWN_EMPTY_REASONS
+            and panel_source == "recorded"
+            and not panel
+        )
+        counts, source = _round_counts(
+            round_dir,
+            loop_rounds,
+            round_index,
+            artifacts.get(round_index, (round_dir, None))[1],
+            known_no_dispatch=known_no_dispatch,
+        )
+        blockers, minors, nits, dismissed = counts
         rows.append(
             RoundRow(
                 run_id=run_id,
                 round=round_index,
                 blockers=blockers,
-                blockers_source=source,
+                minors=minors,
+                nits=nits,
+                dismissed=dismissed,
+                counts_source=source,
                 panel_size=len(panel),
                 panel_source=panel_source,
             )
@@ -252,23 +308,22 @@ def read_rounds(run_dir: Path | str, run_id: str) -> list[RoundRow]:
     return rows
 
 
-def _round_blockers(round_dir: Path, loop_rounds: object, round_index: int) -> tuple[int, str]:
-    try:
-        data = json.loads((round_dir / _SYNTH_ARTIFACT).read_text(encoding="utf-8"))
-    except (OSError, ValueError):
-        data = None
-    consolidated = data.get("consolidated_findings") if isinstance(data, dict) else None
-    if isinstance(consolidated, list) and all(isinstance(f, dict) for f in consolidated):
-        return (
-            sum(
-                1
-                for f in consolidated
-                if f.get("severity") == "blocker" and f.get("dismissed") is not True
-            ),
-            "artifacts",
-        )
-    fallback = _manifest_blockers(round_dir, loop_rounds, round_index)
-    return (fallback, "manifest") if fallback is not None else (0, "unknown")
+def _round_counts(
+    round_dir: Path,
+    loop_rounds: object,
+    round_index: int,
+    artifact: _ArtifactEvidence | None,
+    *,
+    known_no_dispatch: bool,
+) -> tuple[_CountVector, str]:
+    if artifact is not None:
+        return artifact[1], "artifacts"
+    fallback = _manifest_counts(round_dir, loop_rounds, round_index)
+    if fallback is not None:
+        return fallback, "manifest"
+    if known_no_dispatch:
+        return (0, 0, 0, 0), "manifest"
+    return (0, 0, 0, 0), "unknown"
 
 
 def active_blockers(findings: list[FindingRow]) -> int:
@@ -297,7 +352,7 @@ def consensus_stats(conn) -> tuple[int, int] | None:
         """
         WITH multi_rounds AS (
             SELECT run_id, round FROM rounds
-            WHERE panel_size > 1 AND blockers_source = 'artifacts'
+            WHERE panel_size > 1 AND counts_source = 'artifacts'
         ),
         active AS (
             SELECT f.run_id, f.round, f.idx FROM findings f
@@ -329,30 +384,33 @@ def blocker_curve(conn) -> list[tuple[int, int, int]]:
     convergence; it is SURVIVORSHIP, since fewer runs reach each round. Returning both forces a
     renderer to show density, which this repo published wrongly once already.
 
-    ``blockers_source='unknown'`` rounds are EXCLUDED. Their blocker count is 0 by convention
+    ``counts_source='unknown'`` rounds are EXCLUDED. Their blocker count is 0 by convention
     (no evidence either way), not by measurement — including them fabricates zeroes in the curve
     for killed/interrupted runs that left no manifest or artifact. Manifest-backed rounds ARE
     included: they have a measured count, just no per-finding provenance.
     """
     rows = conn.execute(
         "SELECT round, COALESCE(SUM(blockers), 0), COUNT(*) FROM rounds "
-        "WHERE blockers_source != 'unknown' "
+        "WHERE counts_source != 'unknown' AND NOT (panel_source = 'recorded' "
+        "AND panel_size = 0 AND blockers = 0 AND minors = 0 AND nits = 0 AND dismissed = 0) "
         "GROUP BY round ORDER BY round"
     ).fetchall()
     return [(int(r), int(n), int(d)) for r, n, d in rows]
 
 
 def incomplete_rounds(conn) -> int:
-    """Rounds whose blocker count is not artifact-backed — reported, never silently zeroed.
+    """Rounds whose finding counts are not artifact-backed — reported, never silently zeroed.
 
     Excludes deliberate no-dispatch rounds (panel explicitly recorded as empty with no blockers):
     those have no synthesizer by design, not because one is missing. The signature is
-    ``panel_source='recorded' AND panel_size=0 AND blockers=0`` — a round where a manifest
-    explicitly recorded zero reviewers and zero blockers, such as ``no_changes_to_review``.
+    ``panel_source='recorded' AND panel_size=0`` plus an all-zero vector — a round where a
+    manifest explicitly recorded zero reviewers and zero findings, such as
+    ``no_changes_to_review``.
     """
     return int(
         conn.execute(
-            "SELECT COUNT(*) FROM rounds WHERE blockers_source != 'artifacts' "
-            "AND NOT (panel_source = 'recorded' AND panel_size = 0 AND blockers = 0)"
+            "SELECT COUNT(*) FROM rounds WHERE counts_source != 'artifacts' "
+            "AND NOT (counts_source = 'manifest' AND panel_source = 'recorded' AND panel_size = 0 "
+            "AND blockers = 0 AND minors = 0 AND nits = 0 AND dismissed = 0)"
         ).fetchone()[0]
     )