graphite-code 1.0.1__tar.gz → 1.1.0__tar.gz

{graphite_code-1.0.1 → graphite_code-1.1.0}/CHANGELOG.md

@@ -13,6 +13,132 @@ machine-checkable identity; the version is for humans.
 
 [Keep a Changelog]: https://keepachangelog.com/en/1.1.0/
 
+## [Unreleased]
+
+## [1.1.0] — 2026-09-27
+
+A minor release. The agent channel's read surfaces gain fields, which is an
+addition under `docs/compatibility.md`. The channel's audit trail also
+closes three holes: status events taken on trust, deletions nobody saw, and
+an audit gate that could fail open. The graph itself does not change. On
+this repository, measured against the deployed 1.0.1 engine, 7659 of
+7659 node ids survive, 21788 of 21788 edge triples are unchanged, every
+relation count is equal, and `analysis.cycles` is identical. Only the
+engine fingerprint moves, because graphite's own bytes did.
+
+### Added
+
+**Every channel status now says who recorded it, and where each recipient
+stands.** `graphite_channel_list`, `graphite_channel_read` and `graphite
+channel list --json` carry `status_actor`, `status_at` and
+`status_verification` beside `status`, plus `recipients` (each recipient's
+own latest status and its verification, or `null`) and `unreceipted`
+(recipients with no event of any kind). `status` keeps its
+meaning: the newest event by any agent. `graphite_channel_read` also returns
+`history`, where every event carries its actor, time, commit and
+verification grade. `graphite channel show N` prints the same history after
+the body. Measured on the live channel on 2026-09-25: the one folded word
+misstated at least one recipient in 39 of the 212 rounds that carry events.
+Round 256 read `acknowledged` while one of its two recipients had recorded
+nothing. The read tool's description now says that reading records nothing,
+and that `graphite_channel_inbox` registers receipt.
+
+### Fixed
+
+**The channel report now verifies status events against their commits, as it
+already did for rounds.** A status event's `actor` was taken on trust. An
+event written by hand under another agent's trailer, rewritten after its
+commit, or edited and left uncommitted was invisible, because the forged
+actor was a participant and the file was tracked. Each event is now graded
+from one `git log` over `status/`. It is `verified` only when it has exactly
+one commit, a clean working copy, and a trailer naming its actor.
+`status_modified`, `status_discrepancy` and `status_uncommitted` are
+anomalies and fail `ok`. On the live channel all 408 events verified, with
+a planted-forgery control flagged. A comment had claimed this check existed.
+The read surfaces carry the same grade, so an actor is never shown bare:
+`status_verification` sits beside `status_actor`, each recipient's entry has
+its own `verification`, and the human report marks a failing attribution
+`UNVERIFIED`. This closes aramid llm-review finding `53368ee`.
+One trust limit remains, and it is stated here because it bounds what
+"verified" means. Every agent commits under the operator's git identity, so
+a trailer proves which agent label was attached, not which process
+committed. A hand-made commit under the claimed actor's own trailer still
+grades `verified`. Closing that needs signed commits.
+
+**The channel report now sees deletions, and a status event's number is
+never reused.** The report graded only the events and rounds still on disk,
+and a new event took `len(files) + 1`. An agent could therefore delete its
+own `blocked` event, commit the deletion, write a `done` into the same slot,
+and the report still read OK. A round file removed the same way vanished
+from the audit view entirely. The next number is now one past the highest
+the round has ever used, on disk or in history, and a history git cannot
+read refuses the write instead of passing for an empty one. Any status file
+or round that history or the index knows but the working tree lacks is
+reported as `status_deleted` or `round_deleted`, and a hole in a round's
+1..N sequence is reported as `status_seq_gap`. All three fail `ok`. The live channel's history
+holds no deletions or renames, so none fire there. This closes aramid
+llm-review finding `5db5889`.
+
+**Installing the channel's audit gate now fails closed.**
+`ensure_channel_hook` set `core.hooksPath` with `check=False` and always
+reported `changed: True`. A gate git never armed (a locked `.git/config`, or a
+higher-precedence override) was therefore reported as in place, and later
+commits would have passed with no agent trailer. The write now raises on
+failure. The value git will actually use is read back, and anything other
+than `.githooks` raises `hook_not_armed`. `changed` reports the observed
+before-and-after state. This closes aramid llm-review finding `0e87805`.
+
+**Stalling is judged per recipient.** A co-recipient's `done` no longer
+hides a recipient that was handed the round and never followed up. A
+withdrawn or superseded round never stalls. Rows gain `stalled_recipients`.
+The report lists recipients with no receipt per agent under `unreceipted`.
+They are visible but do not fail `ok`, because several registered agents
+have never called inbox, and a check that is always red is one nobody
+reads.
+
+**Reading the channel no longer rewrites its git index.** The report's
+`git status` refreshed stale stat data by rewriting `.git/index` under
+`index.lock`, the lock a concurrent broker `git add` needs. Channel git now
+runs with `GIT_OPTIONAL_LOCKS=0`. A test pins the index bytes across a
+report and a read with stale stat data.
+
+**A PEP 508 marker of the shape `(A) or (B)` was mis-parsed by the doctor's
+MCP distribution walk.** The marker evaluator unwrapped outer parentheses by
+checking only that the text started with `(` and ended with `)`, so
+`(extra == "a") or (python_version == "3.14")` was stripped to
+`extra == "a") or (python_version == "3.14"`. An `extra` marker of that shape
+then failed closed to "does not apply"; a plain marker of that shape raised
+and aborted the whole distribution walk, which is `probe_mcp`'s manifest
+source. Outer parentheses are now unwrapped only when the first `(` is closed
+by the last character, counting depth outside quoted values. Found by the
+new `tests/test_doctor_probes.py`; no installed distribution on the reference
+machine carried the shape, which is why the walk had never failed.
+
+### Changed
+
+**`scripts/mutation_tests.py` targets `scripts/` changes too.** The
+certifying launcher for aramid's mutation gate diffed `src/` only, so a
+mutant in the launcher itself skipped the targeted stage and its confirm ran
+the whole suite (465 s on the gate's first live drain, 2026-09-04, where the
+targeted stage kills in seconds). A changed `scripts/<stem>.py` now targets
+`tests/test_<stem>.py` and `tests/test_<stem>_*.py` like a changed source
+module.
+
+**Twelve modules gained a `tests/test_<stem>.py`.** aramid's mutation stage 1
+runs `tests/test_<module>.py` when it exists and otherwise `pytest -k
+<module>`; a run that selects nothing is booked a stage-1 survivor and every
+such mutant goes to a full-suite confirm, of which an item gets three. Nine
+modules had a `-k` fallback that collected zero tests (`doctor_probes`,
+`dependency_install`, `probe_process`, `ts_bridge`, `_win32_ctypes`,
+`process_contracts`, `routing/ollama_executor`, `routing/context_builder`,
+`routing/route_pool_execution`) and three collected one (`mcp_server`,
+`llm_probe`, `cluster`). Each now has a stage-1 file that pins its pure
+helpers directly; every file was proven able to fail by a hand mutant of its
+module. Three quirks were pinned as-is rather than changed: a cluster's
+kind label is `f"{kind}s"` verbatim (`classs`), a blank path in a TypeScript
+bridge edge normalises to `.` instead of being dropped, and an empty MCP
+`node_id` fuzzy-matches the first node.
+
 ## [1.0.1] — 2026-09-05
 
 A patch release. Measured against the deployed 1.0.0 engine on this repository,

{graphite_code-1.0.1 → graphite_code-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: graphite-code
-Version: 1.0.1
+Version: 1.1.0
 Summary: Local-first, zero-LLM knowledge graph extraction for codebases.
 Project-URL: Homepage, https://github.com/jared0565/graphite
 Project-URL: Repository, https://github.com/jared0565/graphite
@@ -48,7 +48,7 @@ Description-Content-Type: text/markdown
 
 Local-first, deterministic knowledge graph extraction for codebases — zero-LLM, daemon-maintained, agent-agnostic.
 
-**Status: 1.0.1, production/stable.** Published on PyPI as
+**Status: 1.1.0, production/stable.** Published on PyPI as
 [`graphite-code`](https://pypi.org/project/graphite-code/) with PEP 740
 attestations; supported on Windows, Linux and macOS with Python 3.11–3.14
 (every cell gates CI). What 1.x promises — CLI, JSON outputs, `graph.json`,

{graphite_code-1.0.1 → graphite_code-1.1.0}/README.md

@@ -2,7 +2,7 @@
 
 Local-first, deterministic knowledge graph extraction for codebases — zero-LLM, daemon-maintained, agent-agnostic.
 
-**Status: 1.0.1, production/stable.** Published on PyPI as
+**Status: 1.1.0, production/stable.** Published on PyPI as
 [`graphite-code`](https://pypi.org/project/graphite-code/) with PEP 740
 attestations; supported on Windows, Linux and macOS with Python 3.11–3.14
 (every cell gates CI). What 1.x promises — CLI, JSON outputs, `graph.json`,

{graphite_code-1.0.1 → graphite_code-1.1.0}/src/graphite/__init__.py

@@ -38,4 +38,4 @@ __all__ = ["__version__"]
 #: Coarse and hand-maintained by construction. It is a release label, not
 #: evidence that a given fix is present -- to answer that, survey for the marker
 #: the fix introduced, or compare `graphite --version` fingerprints.
-__version__ = "1.0.1"
+__version__ = "1.1.0"

{graphite_code-1.0.1 → graphite_code-1.1.0}/src/graphite/channel.py

@@ -64,10 +64,11 @@ _LOCK_TIMEOUT_SECONDS = 30.0
 # would strand every other agent behind a holder that is already doomed.
 #
 # Note this holds per CALL, not per critical section. `register_agent` runs
-# `ensure_channel_hook`'s config call plus a three-call `_commit`, so a
-# perfectly healthy holder can legitimately sit for ~80s -- well over the 30s a
-# waiter is willing to wait. A `lock_timeout` is therefore not by itself
-# evidence of a wedge.
+# `ensure_channel_hook`'s three config calls (read, set, verify) plus a
+# three-call `_commit`, so a perfectly healthy holder can legitimately sit for
+# ~120s -- well over the 30s a waiter is willing to wait. (A status write is
+# four: the sequence read plus `_commit`.) A `lock_timeout` is therefore not by
+# itself evidence of a wedge.
 _GIT_TIMEOUT_SECONDS = 20.0
 
 #: How long before an unreleased lock is assumed abandoned.
@@ -79,7 +80,7 @@ _GIT_TIMEOUT_SECONDS = 20.0
 #: checking. The `pid` and `host` in the record are DIAGNOSTIC ONLY -- they tell
 #: an operator who to go look at; they are never probed.
 #:
-#: 300s is ~3.7x the ~80s worst-case LEGITIMATE hold derived above. The margin
+#: 300s is 2.5x the ~120s worst-case LEGITIMATE hold derived above. The margin
 #: is lopsided on purpose: breaking a live lock puts two writers in the critical
 #: section, which is the exact failure this lock exists to prevent, and a torn
 #: status directory is worse than a wedge that clears itself five minutes later.
@@ -438,14 +439,29 @@ exit 1
 
 
 def ensure_channel_hook(root: Path) -> dict:
-    """Install/refresh the audit gate and point `core.hooksPath` at it."""
+    """Install/refresh the audit gate and point `core.hooksPath` at it.
+
+    Fails CLOSED. The config call used to run with `check=False` and the result
+    always read `changed: True`, so a gate git never armed (a locked
+    `.git/config`, a higher-precedence override) was reported as in place --
+    and every later commit would have gone through with no trailer. `changed`
+    now describes what was observed before and after, not what was attempted.
+    """
     hooks = root / ".githooks"
     hooks.mkdir(parents=True, exist_ok=True)
     path = hooks / "commit-msg"
+    before = path.read_text(encoding="utf-8") if path.exists() else None
+    armed_before = _git(root, "config", "--get", "core.hooksPath", check=False).strip()
     path.write_text(COMMIT_MSG_HOOK, encoding="utf-8", newline="\n")
     path.chmod(0o755)
-    _git(root, "config", "core.hooksPath", ".githooks", check=False)
-    return {"path": str(path), "changed": True}
+    _git(root, "config", "core.hooksPath", ".githooks")
+    armed = _git(root, "config", "--get", "core.hooksPath", check=False).strip()
+    if armed != ".githooks":
+        raise ChannelError(
+            "hook_not_armed",
+            f"core.hooksPath reads {armed!r}, not '.githooks': the channel's audit gate is not armed",
+        )
+    return {"path": str(path), "changed": before != COMMIT_MSG_HOOK or armed_before != ".githooks"}
 
 
 def _committed_agents(root: Path) -> set[str]:
@@ -699,6 +715,12 @@ def _git(root: Path, *args: str, check: bool = True) -> str:
     `errors="replace"` because git also echoes paths, and a byte sequence that
     is not valid UTF-8 must not be able to take the audit surface down. It also
     makes the decode total, which is what keeps `result.stdout` a `str`.
+
+    `GIT_OPTIONAL_LOCKS=0`: reads run git here too (the report, `read`'s
+    history), beside other agents' brokers writing. A plain `git status`
+    refreshes stale stat data by REWRITING the index under `index.lock`, and a
+    writer's `git add` that meets that lock fails. Only optional locks are
+    skipped; `add` and `commit` still take the ones they need.
     """
     try:
         result = subprocess.run(  # noqa: S603
@@ -710,6 +732,7 @@ def _git(root: Path, *args: str, check: bool = True) -> str:
             check=False,
             stdin=subprocess.DEVNULL,
             timeout=_GIT_TIMEOUT_SECONDS,
+            env={**os.environ, "GIT_OPTIONAL_LOCKS": "0"},
         )
     except subprocess.TimeoutExpired:
         raise ChannelError(
@@ -721,6 +744,21 @@ def _git(root: Path, *args: str, check: bool = True) -> str:
     return result.stdout
 
 
+def _log(root: Path, *args: str) -> str:
+    """`git log` over the channel, where a channel with no commits yet HAS a
+    history: an empty one.
+
+    git exits 128 on `log` before the first commit, and that read as a failure
+    -- `channel list` errored on a fresh channel once list and read graded
+    events against history. Every OTHER failure still raises: the next status
+    number is read from history, and a failed read taken for an empty one
+    hands a deleted event's number out again.
+    """
+    if not _git(root, "rev-parse", "--verify", "--quiet", "HEAD", check=False).strip():
+        return ""
+    return _git(root, "log", *args)
+
+
 def _commit(root: Path, paths: list[str], subject: str, agent: str) -> str:
     message = f"{subject}\n\n{trailer(agent)}\n"
     _git(root, "add", "--", *paths)
@@ -993,6 +1031,86 @@ def current_status(root: Path, number: int) -> dict | None:
     return events[-1] if events else None
 
 
+def status_view(entry: Round, events: list[dict], grader: EventGrader) -> dict:
+    """What a reader needs beside the folded status: who set it, and where EACH
+    recipient stands -- each with whether that attribution checks out.
+
+    The fold alone is one word across every actor. On a shared round it spoke
+    for recipients who had recorded nothing -- round 256 read `acknowledged`
+    while one of its two recipients had no event at all. And an actor is only
+    what the event file CLAIMS: a forged file names a real recipient, so the
+    name travels with its grade against the file's own commit (aramid
+    llm-review 53368eee), never bare.
+    """
+    current = events[-1] if events else None
+    latest: dict[str, dict] = {}
+    for event in events:
+        actor = event.get("actor")
+        if isinstance(actor, str):
+            latest[actor] = event
+
+    def grade(event: dict) -> str | None:
+        return grader.grade(entry.number, event)[0] if entry.number is not None else None
+
+    return {
+        "status": current.get("status") if current else None,
+        "status_actor": current.get("actor") if current else None,
+        "status_at": current.get("at") if current else None,
+        "status_verification": grade(current) if current else None,
+        "recipients": {
+            agent: (
+                {
+                    **{key: latest[agent].get(key) for key in ("status", "at", "seq")},
+                    "verification": grade(latest[agent]),
+                }
+                if agent in latest
+                else None
+            )
+            for agent in entry.to
+        },
+        # No event of any kind: the broker never handed it over (no inbox call)
+        # and the recipient never asserted anything either.
+        "unreceipted": [agent for agent in entry.to if agent not in latest],
+    }
+
+
+def status_history(root: Path, number: int, grader: EventGrader | None = None) -> list[dict]:
+    """Every event for one round, oldest first, each graded against its commit."""
+    events = status_events(root, number)
+    if not events:
+        return []
+    grader = grader or EventGrader.load(root, f"{STATUS_DIRNAME}/{number:03d}")
+    history = []
+    for event in events:
+        verification, created = grader.grade(number, event)
+        item = {key: event.get(key) for key in ("seq", "status", "actor", "broker", "at", "reason")}
+        if event.get("malformed"):
+            item["malformed"] = True
+        item.update(file=event["file"], commit=created, verification=verification)
+        history.append(item)
+    return history
+
+
+def _seq_of(name: str) -> int | None:
+    """The sequence number a status file's name carries (`0003-done.json` -> 3)."""
+    head = name[:4]
+    return int(head) if head.isdigit() else None
+
+
+def _next_seq(root: Path, number: int) -> int:
+    """One past the highest number this round has EVER used, on disk or in history.
+
+    It used to be `len(files) + 1`, which hands a deleted event's number to the
+    next writer: delete your own `blocked`, write `done` into its slot, and the
+    log reads as though `blocked` never happened.
+    """
+    prefix = f"{STATUS_DIRNAME}/{number:03d}"
+    names = [path.name for path in (root / prefix).glob("*.json")]
+    history = _log(root, "--format=", "--name-only", "--", prefix)
+    names += [Path(line.strip()).name for line in history.splitlines() if line.strip()]
+    return max((seq for seq in map(_seq_of, names) if seq is not None), default=0) + 1
+
+
 def _write_status_event(
     root: Path,
     number: int,
@@ -1005,7 +1123,7 @@ def _write_status_event(
     with _Lock(root) as lock:
         directory = _status_dir(root, number)
         directory.mkdir(parents=True, exist_ok=True)
-        seq = len(list(directory.glob("*.json"))) + 1
+        seq = _next_seq(root, number)
         name = f"{seq:04d}-{status}.json"
         target = directory / name
         if target.exists():
@@ -1023,8 +1141,8 @@ def _write_status_event(
             "reason": reason,
         }
         target.write_text(json.dumps(event, indent=2, sort_keys=True) + "\n", encoding="utf-8")
-        # Committed under the actor's trailer so the report can compare the two
-        # and catch an event whose recorded actor is not who committed it.
+        # Committed under the actor's trailer so `_verify_event` can compare the
+        # two and catch an event whose recorded actor is not who committed it.
         event["commit"] = _commit(
             root,
             [f"{STATUS_DIRNAME}/{number:03d}/{name}"],
@@ -1116,12 +1234,13 @@ FAILING_VERIFICATIONS = frozenset({"uncommitted", "modified", "discrepancy"})
 _TRAILER = re.compile(r"^Co-Authored-By:\s*(\S+-agent)\s*<", re.MULTILINE)
 
 
-def _tracked(root: Path) -> set[str]:
-    return {line.strip() for line in _git(root, "ls-files").splitlines() if line.strip()}
+def _tracked(root: Path, *pathspec: str) -> set[str]:
+    out = _git(root, "ls-files", "--", *pathspec)
+    return {line.strip() for line in out.splitlines() if line.strip()}
 
 
 def _commits_for(root: Path, rel: str) -> list[str]:
-    out = _git(root, "log", "--format=%H", "--", rel)
+    out = _log(root, "--format=%H", "--", rel)
     return [line.strip() for line in out.splitlines() if line.strip()]
 
 
@@ -1130,16 +1249,81 @@ def _commit_agent(root: Path, sha: str) -> str | None:
     return match.group(1) if match else None
 
 
-def _dirty(root: Path) -> set[str]:
+def _dirty(root: Path, *pathspec: str) -> set[str]:
     """Tracked files with uncommitted working-tree changes.
 
     Without this, editing a tracked round and simply not committing would grade
     `verified`: the file is tracked and still has exactly one commit.
     """
-    out = _git(root, "status", "--porcelain", "--untracked-files=no")
+    out = _git(root, "status", "--porcelain", "--untracked-files=no", "--", *pathspec)
     return {line[3:].strip().strip('"') for line in out.splitlines() if line.strip()}
 
 
+def _event_commits(root: Path, pathspec: str) -> dict[str, list[tuple[str, str | None]]]:
+    """Every commit touching each file under `pathspec`, newest first, paired
+    with the agent its trailer names.
+
+    ONE `git log` for the whole tree: grading 400 status events one file at a
+    time would be 800 git calls on every report.
+    """
+    out = _log(root, "--format=%x1e%H%x1f%B%x1f", "--name-only", "--", pathspec)
+    commits: dict[str, list[tuple[str, str | None]]] = {}
+    for chunk in out.split("\x1e"):
+        if not chunk.strip():
+            continue
+        sha, body, files = chunk.split("\x1f", 2)
+        match = _TRAILER.search(body)
+        agent = match.group(1) if match else None
+        for line in files.splitlines():
+            if line.strip():
+                commits.setdefault(line.strip(), []).append((sha.strip(), agent))
+    return commits
+
+
+def _verify_event(
+    rel: str,
+    actor: object,
+    tracked: set[str],
+    dirty: set[str],
+    commits: dict[str, list[tuple[str, str | None]]],
+) -> tuple[str, str | None]:
+    """Grade one status event the way `_verify` grades a round: `(grade, sha)`.
+
+    Recipient membership alone cannot catch a forged status -- the forged actor
+    usually IS a recipient. The event's own commit can: an event is written once,
+    by the broker, under its actor's trailer, so a second commit is an edit and a
+    different trailer is someone else speaking for that actor.
+    """
+    history = commits.get(rel, [])
+    if rel not in tracked or not history:
+        return "uncommitted", None
+    created_sha, created_agent = history[-1]
+    if rel in dirty or len(history) > 1:
+        return "modified", created_sha
+    if created_agent != actor:
+        return "discrepancy", created_sha
+    return "verified", created_sha
+
+
+@dataclass(frozen=True)
+class EventGrader:
+    """Grades status events against their own commits, from ONE `ls-files`,
+    `status` and `log` over a pathspec: grading round by round from `channel
+    list` would be three git calls per round."""
+
+    tracked: set[str]
+    dirty: set[str]
+    commits: dict[str, list[tuple[str, str | None]]]
+
+    @classmethod
+    def load(cls, root: Path, pathspec: str = STATUS_DIRNAME) -> EventGrader:
+        return cls(_tracked(root, pathspec), _dirty(root, pathspec), _event_commits(root, pathspec))
+
+    def grade(self, number: int, event: dict) -> tuple[str, str | None]:
+        rel = f"{STATUS_DIRNAME}/{number:03d}/{event['file']}"
+        return _verify_event(rel, event.get("actor"), self.tracked, self.dirty, self.commits)
+
+
 def _verify(root: Path, rel: str, tracked: set[str], dirty: set[str]) -> str:
     """Grade one file against its ORIGINAL committed content, not its current text.
 
@@ -1174,6 +1358,16 @@ def _verify(root: Path, rel: str, tracked: set[str], dirty: set[str]) -> str:
     return "verified"
 
 
+def _deleted(root: Path, ever: set[str]) -> list[str]:
+    """Paths history or the index knows that the working tree no longer has.
+
+    Grading only what is present is blind to the cheapest tampering of all:
+    removal. A committed deletion leaves the file in history; an uncommitted one
+    leaves it in the index. Either way the audit view must show it.
+    """
+    return sorted(rel for rel in ever if not (root / rel).exists())
+
+
 def _parse_at(value: str | None) -> datetime | None:
     try:
         return datetime.strptime(str(value), "%Y-%m-%dT%H:%M:%SZ").replace(tzinfo=timezone.utc)
@@ -1192,25 +1386,53 @@ def build_report(
     now = now or datetime.now(timezone.utc)
     tracked = _tracked(root)
     dirty = _dirty(root)
+    event_commits = _event_commits(root, STATUS_DIRNAME)
+    grader = EventGrader(tracked, dirty, event_commits)
     entries = list_rounds(root)
     numbers = {e.number for e in entries if e.number is not None}
 
     rows: list[dict] = []
     anomalies: list[dict] = []
+    unreceipted: dict[str, list[int]] = {}
+
+    status_prefix = f"{STATUS_DIRNAME}/"
+    for rel in _deleted(root, set(event_commits) | {p for p in tracked if p.startswith(status_prefix)}):
+        parts = rel.split("/")
+        number = int(parts[1]) if len(parts) == 3 and parts[1].isdigit() else None
+        anomalies.append({"round": number, "kind": "status_deleted", "detail": parts[-1]})
+    round_history = _log(root, "--format=", "--name-only", "--", ROUNDS_DIRNAME)
+    ever_rounds = {line.strip() for line in round_history.splitlines() if line.strip()}
+    ever_rounds |= {p for p in tracked if p.startswith(f"{ROUNDS_DIRNAME}/")}
+    for rel in _deleted(root, ever_rounds):
+        match = _ROUND_IN_NAME.search(rel)
+        anomalies.append(
+            {"round": int(match.group(1)) if match else None, "kind": "round_deleted", "detail": rel}
+        )
     for entry in entries:
         rel = entry.path.relative_to(root).as_posix()
         verification = _verify(root, rel, tracked, dirty)
         events = status_events(root, entry.number) if entry.number is not None else []
         current = events[-1] if events else None
-
-        stalled = False
-        if current and current.get("status") in {"delivered", "acknowledged"}:
-            at = _parse_at(current.get("at"))
-            stalled = at is not None and (now - at) > timedelta(days=stale_days)
+        view = status_view(entry, events, grader)
+
+        # Per recipient: another recipient's `done` must not hide one that was
+        # handed the round and never followed up. An author's withdrawal ends it.
+        stalled_recipients: list[str] = []
+        if not current or current.get("status") not in {"withdrawn", "superseded"}:
+            for agent, state in view["recipients"].items():
+                if state and state["status"] in {"delivered", "acknowledged"}:
+                    at = _parse_at(state["at"])
+                    if at is not None and (now - at) > timedelta(days=stale_days):
+                        stalled_recipients.append(agent)
+        for agent in view["unreceipted"]:
+            if entry.number is not None:
+                unreceipted.setdefault(agent, []).append(entry.number)
 
         participants = {entry.author, *entry.to} - {None}
         for event in events:
             number = entry.number
+            if number is None:  # never taken: events are only read for numbered rounds
+                continue
             if event.get("malformed"):
                 anomalies.append({"round": number, "kind": "malformed_status", "detail": event.get("file")})
                 continue
@@ -1219,9 +1441,16 @@ def build_report(
                 anomalies.append(
                     {"round": number, "kind": "status_actor_not_participant", "detail": actor}
                 )
-            event_rel = f"{STATUS_DIRNAME}/{number:03d}/{event['file']}"
-            if event_rel not in tracked:
-                anomalies.append({"round": number, "kind": "status_uncommitted", "detail": event["file"]})
+            grade, _sha = grader.grade(number, event)
+            if grade != "verified":
+                anomalies.append({"round": number, "kind": f"status_{grade}", "detail": event["file"]})
+        # Numbers are handed out 1..N and never reused, so a hole is an event
+        # that existed and is gone -- or one written by hand, skipping ahead.
+        seqs = sorted(seq for seq in (_seq_of(e["file"]) for e in events) if seq is not None)
+        if seqs != list(range(1, len(seqs) + 1)):
+            anomalies.append(
+                {"round": entry.number, "kind": "status_seq_gap", "detail": ",".join(map(str, seqs))}
+            )
         seen = [e.get("status") for e in events]
         if "done" in seen and "delivered" not in seen[: seen.index("done")]:
             anomalies.append({"round": entry.number, "kind": "done_without_delivery", "detail": None})
@@ -1240,11 +1469,10 @@ def build_report(
                 "posted": entry.posted,
                 "supersedes": entry.supersedes,
                 "verification": verification,
-                "status": current.get("status") if current else None,
-                "status_actor": current.get("actor") if current else None,
-                "status_at": current.get("at") if current else None,
+                **view,
                 "reason": current.get("reason") if current else None,
-                "stalled": stalled,
+                "stalled": bool(stalled_recipients),
+                "stalled_recipients": stalled_recipients,
             }
         )
 
@@ -1266,6 +1494,10 @@ def build_report(
         "stalled": [r for r in rows if r["stalled"]],
         "anomalies": anomalies,
         "by_agent": by_agent,
+        # Visible, NOT failing: registered agents that never call inbox would
+        # otherwise hold the report permanently red, and a check that is always
+        # red is one nobody reads.
+        "unreceipted": dict(sorted(unreceipted.items())),
         # Who may write at all. Without this the operator can see what was said
         # but not who is able to say anything -- and an agent that was onboarded
         # but never registered is silently mute rather than visibly absent.
@@ -1294,8 +1526,23 @@ def render_report(data: dict) -> str:
             f"{label:<10} {row['author'] or '(legacy)':<16} -> {recipients:<16} "
             f"{status:<13} {row['verification'].upper():<12} {row['title']}"
         )
+        if row["status"] is not None:
+            # The actor is what the event file claims; say so when its commit disagrees.
+            checked = row.get("status_verification")
+            flag = "" if checked == "verified" else f"  UNVERIFIED: {str(checked).upper()}"
+            lines.append(f"{'':<10}   set by {row['status_actor']} at {row['status_at']}{flag}")
+        states = row.get("recipients") or {}
+        # One line per recipient wherever the folded word misleads: it names a
+        # status some recipient never recorded.
+        if any((state or {}).get("status") != row["status"] for state in states.values()):
+            for agent, state in states.items():
+                own = f"{state['status'].upper():<13} {state['at']}" if state else "NO RECEIPT"
+                if state and state.get("verification") != "verified":
+                    own += f"  UNVERIFIED: {str(state.get('verification')).upper()}"
+                lines.append(f"{'':<10}   {agent:<28} {own}")
         if row["stalled"]:
-            lines.append(f"{'':<10}   ^ STALLED — {status.lower()} since {row['status_at']}, no follow-up")
+            who = ", ".join(row["stalled_recipients"])
+            lines.append(f"{'':<10}   ^ STALLED — {who}: delivered or acknowledged, no follow-up")
         if row["reason"]:
             lines.append(f"{'':<10}   \"{row['reason']}\"")
 
@@ -1306,6 +1553,12 @@ def render_report(data: dict) -> str:
     if not registry:
         lines.append("  (none — no agent can post; graphite channel register <repo> <name>-agent)")
 
+    unreceipted = data.get("unreceipted") or {}
+    if unreceipted:
+        lines += ["", "No receipt recorded — addressed, but no event of any kind (never called inbox):"]
+        for agent, rounds in unreceipted.items():
+            lines.append(f"  {agent:<28} {len(rounds):>3} round(s): {', '.join(map(str, rounds))}")
+
     legacy = data["counts"]["legacy"]
     if legacy:
         lines += [