diff --git a/tools/doc_census_check.py b/tools/doc_census_check.py
index 3b36362..f5251e4 100644
--- a/tools/doc_census_check.py
+++ b/tools/doc_census_check.py
@@ -59,8 +59,15 @@ TWO ORACLE LEGS, AND WHY THE SECOND ONE EXISTS
   only when no leg survives, because a failed run is not a reason to stop
   looking. A revision that will not materialise fails the same way rather than
   producing a census at all: an empty queue is a census of zeros, and reading it
-  as that revision's census is the phantom this rule refuses (measured
-  2026-10-16 against a sha256 prefix read as a revision).
+  as that revision's census is the phantom this rule refuses.
+
+  A HEX RUN INTRODUCED AS A DIGEST IS NOT A REVISION. A block that quotes a
+  truncated sha256 in its prose is a size, not a place: read as a rev it files
+  the block under a revision that cannot exist, fails that leg, and then
+  adjudicates every claim in the block again beside the real ones. Two signals
+  are read, both local to the token -- a digest word in front of it (`sha256
+  <hex>`, `hash <hex>`), or an ellipsis behind it (`<hex>…`), which is how this
+  archive writes a truncated digest. See `block_revs`.
 
   The run leg is `<script> --repo R --rev REV`. A tool that takes no `--rev`
   answers it with an argparse diagnosis and prints no census at all, so the leg
@@ -142,6 +149,33 @@ CLAIM_EQ = re.compile(
     r"(?P<unit>[A-Za-z_][A-Za-z0-9_]*)\s*[:=]\s*\**\s*(?P<num>[0-9][0-9,]*)")
 REV_LONG = re.compile(r"\b[0-9a-f]{7,40}\b")
 
+# A hex run introduced as a DIGEST is not a revision, and reading it as one costs
+# more than a wrong label: the block is filed under a revision that cannot exist,
+# its leg fails, and then every claim in the block is adjudicated once per
+# spurious rev beside the real ones. Measured 2026-10-16 at HEAD on
+# `tools/queue_claim_check.py`, whose UNITS block quotes the queue's size as
+# "/ sha256 `fbe51445a89f81ab…`": three claims emitted FOUR times, once per
+# REV_LONG token, and two `git show <sha256-prefix>:WORK-QUEUE.md` leg failures.
+# Two signals, both local to the token: a digest word in front of it (sha256,
+# sha1, md5, digest, hash), or an ellipsis behind it -- the archive's own way of
+# writing a truncated digest. A revision cited in the ordinary way carries
+# neither, and a FULL sha256 is already invisible to REV_LONG: the run has no
+# word boundary to bite on.
+DIGEST_BEFORE = re.compile(
+    r"(?:sha[-\s]?256|sha[-\s]?1|md5|digest|hash)\s*[:=]?\s*[`'\"]?\s*$", re.I)
+DIGEST_AFTER = re.compile(r"^[`'\"]?\s*(?:…|\.\.\.)")
+
+
+def block_revs(text):
+    """The revisions a block names -- hex runs read as digests excluded."""
+    out = set()
+    for m in REV_LONG.finditer(text):
+        if DIGEST_BEFORE.search(text[:m.start()]) or \
+                DIGEST_AFTER.match(text[m.end():]):
+            continue
+        out.add(m.group(0))
+    return sorted(out)
+
 # Function words and units this tool does not adjudicate. `at` in "2026-10-15 at
 # rev 9188dd3" is not a census quantity; neither is `B` (bytes differ by
 # revision by design, and "1,201,550 B" is a size, not a count). Stated so the
@@ -440,7 +474,7 @@ def _fixture_checks():
     lines = FAKE_DOC.split("\n")
     got, first_block, revs_seen = [], [], set()
     for first, blk in blocks(lines, 1, len(lines)):
-        revs = sorted(set(REV_LONG.findall("\n".join(r for _, r in blk))))
+        revs = block_revs("\n".join(r for _, r in blk))
         revs_seen |= set(revs)
         for ln, val, unit, _tok, _pos in claims_in(blk):
             got.append((unit, val))
@@ -453,6 +487,16 @@ def _fixture_checks():
     check("claims: `471 cannot be resolved` is not a claim",
           any(u in ("cannot", "resolved") for u, _ in got), False)
     check("claims: the block's rev is read", "babdadc" in revs_seen, True)
+    # the digest rule, one signal per cell, and the negative control between
+    # them -- the text of each is the text of the defect, measured at HEAD
+    check("revs: `sha256 <hex>` is a digest, not the block's revision",
+          block_revs("queue 1,170,483 B / sha256 `c3b4a290dc64bd24`"), [])
+    check("revs: an ellipsis-truncated hex run is a digest, not a revision",
+          block_revs("at `28ca8e5` (1,193,681 B / `c3b4a290dc64bd24…`)"),
+          ["28ca8e5"])
+    check("revs: an ordinarily cited revision is still the block's revision",
+          block_revs("Run 37 read (`29a4872`, queue 1,170,483 B) and `28ca8e5`"),
+          ["28ca8e5", "29a4872"])
     check("oracle: 471 matches", oracle(printed, clone, "UNRESOLVED", 471),
           ("MATCHES", ""))
     check("oracle: 441 is stale", oracle(printed, clone, "UNRESOLVED", 441),
@@ -689,7 +733,7 @@ def check_tool(repo, script, name, cache, run=True, tmpdir=".", isolation=240):
     blk_claims = []
     for first, blk in blocks(lines, lo, hi):
         btext = "\n".join(raw for _, raw in blk)
-        revs = sorted(set(REV_LONG.findall(btext)))
+        revs = block_revs(btext)
         cl = claims_in(blk)
         if cl:
             blk_claims.append((first, revs, cl, btext))