From 8591be98e1e224b25136e09ae3ec679499ceb624 Mon Sep 17 00:00:00 2001
From: EMRG Evolution <emrg@argszero.dev>
Date: Sat, 17 Oct 2026 07:03:15 +0800
Subject: [PATCH 1/2] emrg: only a head the voting cycle itself pushed is
 abstained on (#2338)

---
 emrg/server/evolution_prompt.md               |    2 +-
 scripts/cast-vote.py                          |  172 +--
 scripts/check-vote-count.py                   |   67 +-
 scripts/review-queue.py                       |  938 ++-------------
 tests/test_cast_vote.py                       |  362 +-----
 tests/test_check_vote_count.py                |  207 +---
 ...rinted_commands_carry_the_python_runner.py |   18 +-
 tests/test_review_queue.py                    | 1036 +++--------------
 8 files changed, 454 insertions(+), 2348 deletions(-)

diff --git a/emrg/server/evolution_prompt.md b/emrg/server/evolution_prompt.md
index af6e4ae5..22bcaabc 100644
--- a/emrg/server/evolution_prompt.md
+++ b/emrg/server/evolution_prompt.md
@@ -298,7 +298,7 @@ Vote history misleads in both directions, so ask `scripts/check-vote-count.py` (
 
 **An old head carrying votes is not refreshed.** A push moves the head and **voids every vote standing on it**, so the tempting "just fix it up" destroys the thing it means to preserve: measure the tree it would land with `scripts/check-merge-freshness.py` and `scripts/check-merge-plan-suite.py` instead of refreshing, and vote on that reading — the head does not move, so the standing votes stay valid. The refreshing shape is `git fetch origin master && git merge FETCH_HEAD` and then push; rebase cannot ship here (the push is rejected, and the force-push it needs is forbidden).
 
-**Abstention**: a cycle neither votes on nor merges a head it pushed itself, nor one pushed by the cycle immediately before it. A *cycle* here and everywhere in this file is **one run of this loop**, not the instance: a PR an earlier run pushed is one this run may review and vote on, and a PR this run pushed is not.
+**Abstention**: a cycle neither votes on nor merges a head it pushed itself — the cycle's own run, and only that. A *cycle* here and everywhere in this file is **one run of this loop**, not the instance: a PR an earlier run pushed is one this run may review and vote on, and a PR this run pushed is not. The clause reads the head's push instant against this cycle's own run (from its own start to the start of the cycle that follows it), so a push before that run or after it belongs to whoever made it: the requirement "nor one pushed by the cycle immediately before it" is not part of the rule.
 
 **A parallel-cycle merge race is not a failure**: two cycles can both see the 3rd vote and call `gh pr merge`; the loser gets "not mergeable" or "already merged". Re-read `gh pr view <N> --json state,mergedAt` — a set `mergedAt` means it landed, possibly by the other cycle; fetch master and confirm the commit is on `FETCH_HEAD`. Only a genuine rejection (conflict, red CI, ❌) blocks.
 
diff --git a/scripts/cast-vote.py b/scripts/cast-vote.py
index 4fc149b7..e9ba33dc 100644
--- a/scripts/cast-vote.py
+++ b/scripts/cast-vote.py
@@ -128,22 +128,18 @@
 window, and the sibling reported `abstain` for it minutes later.
 
 So the clause is applied here too, from the same reading, and refuses to post. The
-window is the previous cycle's start when it can be found (`--prev-cycle`, else the
-newest cycle record that sorts before this cycle's id in `--cycles-log`, default
+window is this cycle's own run: it starts at this cycle's own id — a cycle id *is* its
+start instant, so the near bound needs no corpus — and ends where the cycle that follows
+begins, read from the newest cycle record in `--cycles-log` (default
 `$EMRG_CYCLES_LOG`, else the directory the evolution template names: the project memory
-root inside this checkout) and this
-cycle's own start
-when it cannot — narrowed and said so, never abandoned and never widened by a guess.
-A head whose push time fell back to the commit date is **refused rather than judged**:
-a lower bound cannot decide a window, so nothing is posted and the refusal names the
-remedy that same missing run already has — get a run for the head, then ask again. The
-counter calls such a head blocking for that same missing run, so the cost is a delay
-rather than a vote nobody can recount. The other uncertain input — no previous cycle to
-widen the window from — is *narrowed* rather than refused: the head is judged over this
-cycle's own start and the narrowing is reported, because a clause applied over a smaller
-window is a weaker reading than the rule states and must not pass as the stronger one.
-Only a cycle id that names no instant at all leaves the clause inapplicable, and that is
-a refusal.
+root inside this checkout). A push below the start belongs to whoever made it before
+this cycle ran, so the vote counts; the host ruled the older, wider reading away on
+2026-10-16T22:18:15. A head whose push time fell back to the commit date is **refused
+rather than judged**: a lower bound cannot decide a window, so nothing is posted and
+the refusal names the remedy that same missing run already has — get a run for the head,
+then ask again. The counter calls such a head blocking for that same missing run, so the
+cost is a delay rather than a vote nobody can recount. Only a cycle id that names no
+instant at all leaves the clause inapplicable, and that is a refusal.
 
 Why `-` exists (issue #1462)
 ----------------------------
@@ -327,12 +323,11 @@ def votes_counter():
 
 
 #: The sibling that owns the abstention window (issue #1408; the reading itself landed
-#: with PR #1498). The clause — *a cycle does not vote on a head it pushed*, with the
-#: window immediately before this one counted as one's own — is defined there: its two
-#: ends, its narrowed form when the previous cycle cannot be found, and why an inexact
-#: push time never decides it. This tool asks for that reading rather than deriving a
-#: second one, because a second reading of "whose head is this" is a second answer to
-#: one question, and the two would disagree exactly when it matters.
+#: with PR #1498). The clause — *a cycle does not vote on a head it pushed* — is
+#: defined there: its two ends, and why an inexact push time never decides it. This
+#: tool asks for that reading rather than deriving a second one, because a second
+#: reading of "whose head is this" is a second answer to one question, and the two
+#: would disagree exactly when it matters.
 _QUEUE = Path(__file__).resolve().parent / "review-queue.py"
 _queue: object | None = None
 
@@ -521,15 +516,14 @@ def tree_claim_refusal(body: str, pr: int, repo: str) -> tuple[str | None, str]:
 def own_head_window(
     cycle: str,
     verdict: object,
-    prev_cycle: str | None = None,
     cycles_log: str | None = None,
 ) -> tuple[str, str]:
     """The abstention clause, applied at the moment the vote would be spent.
 
     Answers `(refusal, note)`: a non-empty `refusal` means **nothing was posted**,
-    and `note` is what to say when it is empty. `note` is also where a *narrowed*
-    window is reported — a clause applied over this cycle alone is a strictly weaker
-    reading than the one the rule states, so it says so rather than passing as it.
+    and `note` is what to say when it is empty — it carries the one exemption that
+    a *reading* decided rather than the clock (a head provably pushed by another
+    instance), so a reader can see which datum decided.
 
     Why this is here and not only in `review-queue.py`: that tool answers "may this
     cycle vote here" **when a cycle asks it**, and a cycle that does not ask spends
@@ -540,6 +534,14 @@ def own_head_window(
     reported `abstain` for that same head minutes later, from the same window this
     refuses on.
 
+    **The window is this cycle's own run** — from its own start to the start of the
+    cycle that follows it — and only a push inside it is refused. The host ruled the
+    wider reading away on 2026-10-16T22:18:15 ("I think the requirement 'nor one pushed
+    by the cycle immediately before it' should not exist. That the cycle that pushed it
+    cannot vote is already enough" — translated from the Chinese original): a head the
+    *previous* cycle pushed is no longer this cycle's own work, and a push below this
+    cycle's own start belongs to whoever made it.
+
     **An undecidable window is a refusal, not a pass** — that is the sibling's own
     rule (`an unresolved window is never reported as a pass`) and it is the only
     direction that costs a delay instead of a vote nobody can recount. A head with no
@@ -568,33 +570,16 @@ def own_head_window(
             "instance's work and the abstention clause is not asked of it"
         )
     # One producer for the window, shared with the queue that prints the verdict and the
-    # counter that voids a posted vote (`review-queue.own_window`). Resolved here from
-    # the records alone it was too early for 20 of the corpus's 350 cycle records
-    # (measured 2026-10-14), so a head pushed in such a gap was refused a vote it was
-    # entitled to post - a vote lost to an arithmetic difference between carriers rather
-    # than to the clause (issue #2218). `prev_cycle` is the caller's own answer and is
-    # not second-guessed.
-    window = queue.own_window(cycle, prev_cycle, cycles_log)
-
-    note = ""
-    if window.unresolved:
-        narrowed = (
-            f"only pushes at or after {window.window_start_text()} were checked"
-            if window.applied
-            else "and this cycle's own id names no instant"
-        )
-        note = (
-            "the abstention window could not be widened to the cycle before this one "
-            f"({window.unresolved}); it was applied as {window.source or 'nothing'} - "
-            f"{narrowed}"
-        )
+    # counter that voids a posted vote (`review-queue.own_window`), so the same head
+    # cannot read `vote` in one and be refused by another (issue #2218).
+    window = queue.own_window(cycle, cycles_log)
 
     if not window.applied:
         return (
-            f"the abstention clause cannot be applied: {note}. Nothing was posted - a "
-            "vote that may be this cycle's own work is not worth spending, and the "
-            "clause is the reason the question is asked at all (issue #1408)"
-        ), note
+            f"the abstention clause cannot be applied: {window.unresolved}. Nothing was "
+            "posted - a vote that may be this cycle's own work is not worth spending, and "
+            "the clause is the reason the question is asked at all (issue #1408)"
+        ), ""
 
     head = str(getattr(verdict, "head_sha", ""))
     push_time = str(getattr(verdict, "push_time", ""))
@@ -609,62 +594,35 @@ def own_head_window(
             "(`gh workflow run test.yml --ref <branch>`, or "
             "`bash scripts/re-trigger-ci.sh <branch>`), then ask again - "
             f"`{RUNNER} scripts/review-queue.py --cycle <id>` reads the same head the same way"
-        ), note
+        ), ""
 
     pushed = queue.instant(push_time)
     if pushed is None:
         return (
             f"the window cannot be decided from head {head[:8]}: its push time "
             f"({push_time!r}) is not an instant. Nothing was posted"
-        ), note
-
-    if window.boundary_unmeasured and pushed < window.start:
-        # Issue #2275's posting half: the narrowed window is real, its far end is not, and
-        # this push falls below the start — so whether it is inside the window this cycle
-        # treats as its own was never decided. Posting under it spends a vote the counter
-        # voids, which is the one thing this tool exists to prevent; the counter takes the
-        # same branch (both ask `Window.boundary_unmeasured`), so the two readings cannot
-        # disagree about the same head.
-        return (
-            f"the head {head[:8]} was pushed {push_time}, below the window this cycle "
-            f"treats as its own, which starts {window.window_start_text()} "
-            f"({window.source}) - and the boundary the wider window uses, the start of the "
-            "cycle before this one, which is earlier than that start, was never "
-            f"measured, because the cycle-record corpus could not be read "
-            f"({window.corpus_shortfall}). Whether the push falls inside the window this "
-            "clause asks about cannot be decided from here, and a boundary nobody measured "
-            "is not passed: the narrowed window would credit a vote cast inside the one "
-            "that was never read. Nothing was posted. Pass the corpus the window needs - "
-            f"`--cycles-log DIR` (or `--prev-cycle <id>`) - and ask again (issue #2275)"
-        ), note
-
-    if window.covers(pushed):
-        # The same disclosure the report carries, from the same producer: a window read
-        # off the records can be wider than the clause, and here that costs a *posted
-        # vote* rather than a reading - this refusal is the one place a cycle cannot
-        # simply re-read next cycle (issue #2214).
-        #
-        # Both ends of the span, not its start alone (issue #2334). A posting cycle is the
-        # newest one, so its far bound is open and this is the comparison it always was;
-        # the far end is asked all the same, because the predicate the three carriers share
-        # is the one place that difference is allowed to live.
-        widened = f" {window.inferred_clause()}." if window.inferred else ""
-        far = f", until {window.window_end_text()}" if window.end is not None else ""
-        return (
-            f"the head {head[:8]} was pushed {push_time}, inside the window this cycle "
-            f"treats as its own, which starts {window.window_start_text()}{far} "
-            f"({window.source}) - a cycle does not vote on a head it pushed, and the "
-            "window immediately before this one counts as its own as well, because every "
-            f"cycle on a host is the same instance running again.{widened} "
-            "Nothing was posted. The next vote here has to come from a later cycle "
-            "(the same head is an `abstain` row in "
-            f"`{RUNNER} scripts/review-queue.py --cycle <id>`); if the head is stale and its "
-            "votes are at risk, measure the tree the merge would land instead of "
-            "refreshing it - a push voids the votes it was meant to preserve "
-            f"(`{RUNNER} scripts/check-merge-plan-suite.py <PR>`)"
-        ), note
-
-    return "", note
+        ), ""
+
+    # The clause's span has **two** ends, and both of them can put a push outside it: a
+    # push below `start` belongs to whoever made it before this cycle began, and one at
+    # or after `end` belongs to the cycle that followed (issue #2334). Only a push inside
+    # the run is this cycle's own work, so this is the comparison that decides — and it is
+    # the same predicate the queue prints and the counter voids on.
+    if not window.covers(pushed):
+        return "", ""
+
+    far = f", until {window.window_end_text()}" if window.end is not None else ""
+    return (
+        f"the head {head[:8]} was pushed {push_time}, inside the run this cycle treats "
+        f"as its own, which starts {window.window_start_text()}{far} "
+        f"({window.source}) - a cycle does not vote on a head it pushed. "
+        "Nothing was posted. The next vote here has to come from a later cycle "
+        "(the same head is an `abstain` row in "
+        f"`{RUNNER} scripts/review-queue.py --cycle <id>`); if the head is stale and its "
+        "votes are at risk, measure the tree the merge would land instead of "
+        "refreshing it - a push voids the votes it was meant to preserve "
+        f"(`{RUNNER} scripts/check-merge-plan-suite.py <PR>`)"
+    ), ""
 
 
 def _gh(args: list[str], stdin: str | None = None) -> subprocess.CompletedProcess:
@@ -926,18 +884,12 @@ def main(argv: list[str] | None = None) -> int:
         default=None,
         help="the cycle id the vote is cast under; must be the one in the body",
     )
-    parser.add_argument(
-        "--prev-cycle",
-        default=None,
-        help="the cycle immediately before this one, whose start is the abstention "
-        "window's start; read from the cycle records when omitted",
-    )
     parser.add_argument(
         "--cycles-log",
         default=None,
         help="directory (or several, joined by `os.pathsep`) holding the "
-        "`cycle-<date>-<time>.md` records the previous cycle is read from when "
-        "--prev-cycle is not given (default: $EMRG_CYCLES_LOG, else the project "
+        "`cycle-<date>-<time>.md` records, read for the cycle that follows this one "
+        "- the window's far bound (default: $EMRG_CYCLES_LOG, else the project "
         "memory root inside this checkout)",
     )
     parser.add_argument("--repo", default=REPO, help="owner/name the PR lives in")
@@ -1030,12 +982,12 @@ def main(argv: list[str] | None = None) -> int:
         print(f"note: {note}", file=sys.stderr)
 
     refusal, window_note = own_head_window(
-        cycle, verdict, prev_cycle=args.prev_cycle, cycles_log=args.cycles_log
+        cycle, verdict, cycles_log=args.cycles_log
     )
     if window_note:
         # Ahead of the refusal, because the note describes the *reading* rather than the
-        # outcome: a window narrowed to this cycle alone is weaker than the rule states,
-        # and the refusal it produces is exactly the case a reader has to know that for.
+        # outcome: a head provably pushed by another instance is exempt from the clause
+        # altogether, and that is what the refusal beside it has to be read against.
         print(f"note: {window_note}", file=sys.stderr)
     if refusal:
         print(f"refusing to post: {refusal}", file=sys.stderr)
diff --git a/scripts/check-vote-count.py b/scripts/check-vote-count.py
index c7c2bf9b..642b0dfa 100644
--- a/scripts/check-vote-count.py
+++ b/scripts/check-vote-count.py
@@ -703,14 +703,14 @@ def own_head_window(
       An unknown one - an empty string, or no login that can be read - keeps the clause,
       so this can only ever un-void a push that is provably someone else's, never credit
       a self-review.
-    * **The window.** The previous cycle's start when its record can be found, this
-      cycle's own start when it cannot — `abstain_window`'s narrowed form, and the
-      reason says which of the two was applied, because a window that could not be
-      widened is a strictly weaker reading and must not pass as the stronger one.
-      It is read through `review-queue.own_window`, the *only* producer of it, so the
-      counter reaches the same boundary the queue does: resolved from the records alone
-      it was too early for 20 of the corpus's 350 cycle records (measured 2026-10-14),
-      which voided a vote the queue would have called votable (issue #2218).
+    * **The window.** The span is this cycle's own run: from its own start to the start
+      of the cycle that follows it. It is read through `review-queue.own_window`, the
+      *only* producer of it, so the counter reaches the same boundary the queue does
+      (issue #2218). Only a push inside the run is this cycle's own work: one below the
+      start was pushed by somebody else before this cycle began, and one at or after the
+      far end belongs to the cycle that followed (issue #2334). The host ruled the wider
+      near bound away on 2026-10-16T22:18:15 - a head the *previous* cycle pushed is not
+      this cycle's own work either.
     * **An unresolvable window is not passed.** A cycle id that names no instant
       leaves nothing to compare, and the direction that costs a delay is preferred
       to the one that spends a vote (the sibling's rule, `cast-vote.py`'s refusal).
@@ -742,20 +742,15 @@ def own_head_window(
             f"the head's own window cannot be decided from push time {push_time!r}, "
             "which is not an instant (issue #1408)"
         )
-    # The clause's span has **two** ends: inside is `start <= pushed < end`, and a push at
-    # or after the far end belongs to the cycle that followed this one, so it is not this
+    # The clause's span has **two** ends: inside is `start <= pushed < end`. A push at or
+    # after the far end belongs to the cycle that followed this one, so it is not this
     # cycle's work and the vote counts (issue #2334). Without the far end the span reached
     # forward without limit: `cyc20261016-181619`, which pushed nothing, had its vote on a
     # head `cyc20261016-183420` pushed voided, and the release PR #2326 waited a cycle at
-    # 2/3 for it.
-    #
-    # `below_unmeasured` keeps issue #2275's state apart from that answer: a push *below*
-    # the start is the one boundary that was never measured, and it is not the same finding
-    # as a push above the far end - the narrowed window credits a vote where the one that
-    # was never read would have voided it, while a push above the far end is outside a span
-    # whose other end *was* measured.
-    below_unmeasured = window.boundary_unmeasured and pushed < window.start
-    if not window.covers(pushed) and not below_unmeasured:
+    # 2/3 for it. A push *before* the start is outside for the same reason in the other
+    # direction: it was pushed by somebody else before this cycle ran, and the host ruled
+    # the previous cycle's window away on 2026-10-16T22:18:15, so the vote counts.
+    if not window.covers(pushed):
         return False, ""
     # The clause is about a head *this* instance pushed, and the window is only a proxy
     # for that: a head the peer pushed inside a gap between this host's cycles fell inside
@@ -773,32 +768,6 @@ def own_head_window(
             f"counts - the head was pushed by {pusher}, which is not a login this "
             "instance pushes under, so the own-head clause is not asked of it"
         )
-    if pushed < window.start:
-        # Reached only where `boundary_unmeasured` let the push through the return above,
-        # and it is the state that made this fix necessary (issue #2275): the window is
-        # real but its *far end* is not, so a push below the narrowed start is a push the
-        # wider window would have decided - the clause cannot say "outside" from an end
-        # nobody measured, and `(True, why)` is how both tools refuse to decide. The
-        # wording is this state's own and not the in-window sentence below: a reason that
-        # says "at or after <start>" about a push *before* it is false, and this family
-        # has paid for a reason that named the wrong cause.
-        return True, (
-            "the head's own window cannot be decided from this vote's cycle: the "
-            f"cycle-record corpus could not be read ({window.corpus_shortfall}), so the "
-            "start of the cycle before this one - the boundary the wider window uses, "
-            f"which is earlier than this cycle's own start "
-            f"({window.window_start_text()}) - was never measured, and the head was pushed "
-            f"{push_time}, before that start. The wider "
-            "window this clause asks about would have decided that push, and a boundary "
-            "nobody measured is not passed, because the narrowed window below it credits "
-            "a vote cast inside the one that was never read (issue #2275)"
-        )
-    narrowed = (
-        f"; the window could not be widened to the cycle before this one ({window.unresolved})"
-        if window.unresolved
-        else ""
-    )
-    widened = f" {window.inferred_clause()}." if window.inferred else ""
     far = f", until {window.window_end_text()}" if window.end is not None else ""
     # What this reason may say is bounded by what it is a reason *about*: this counter
     # reads reviews that were posted, so a sentence saying `cast-vote.py` refused to post
@@ -808,12 +777,10 @@ def own_head_window(
     # posting refusal is true where it lives, in `cast-vote.py::own_head_window`; the
     # *state* clauses above stay, because both tools share the state.
     return True, (
-        f"cast inside the window this vote's cycle treats as its own - the head was "
+        f"cast inside the run this vote's cycle treats as its own - the head was "
         f"pushed {push_time}, at or after {window.window_start_text()}{far} "
-        f"({window.source}"
-        f"{narrowed}); a cycle does not vote on a head it pushed, and the window "
-        "immediately before it counts as its own, so this vote counts for nobody "
-        f"(issue #1408).{widened}"
+        f"({window.source}); a cycle does not vote on a head it pushed, so this vote "
+        "counts for nobody (issue #1408)."
     )
 
 
diff --git a/scripts/review-queue.py b/scripts/review-queue.py
index 600ab720..e4b555fb 100644
--- a/scripts/review-queue.py
+++ b/scripts/review-queue.py
@@ -114,30 +114,26 @@
 The other half of "may this cycle vote here" is the clause the counter cannot see
 -------------------------------------------------------------------------------
 Issue #1408. The clause is **a cycle does not vote on a head it pushed** (nor merge
-it) and, because every cycle on a host is the same instance running again, the
-**immediately preceding cycle's window counts as one's own** — the applied precedent
-is `cyc20260917-125823`, which refused to endorse `#1315`'s head 25 minutes after
-`cyc20260917-122459` pushed it. It has been applied by hand every cycle since, and
-two measured cycles show the cost in both directions: `cyc20260919-065231` cast a
-vote on the head it had just refreshed and had to withdraw it by hand, and
-`cyc20260920-214143` found this tool answering `vote` for two heads the cycle
-immediately before it had pushed.
+it), and the window that decides it is that cycle's **own run**: from its start to the
+start of the cycle that follows it. The host ruled the older, wider reading away on
+2026-10-16T22:18:15 ("I think the requirement 'nor one pushed by the cycle immediately
+before it' should not exist. That the cycle that pushed it cannot vote is already
+enough" — translated from the Chinese original), so a head the immediately preceding
+cycle pushed is no longer read as this cycle's own work.
 
 *Who pushed a head* is not a fact GitHub records, so the clause has to be read off
 the clock, and a cycle id **is** its start time in the host's local zone
-(`cyc20260917-221117` began at 22:11:17 local). So the window is decidable from two
-datums this tool already has — the push time (the counter prints it) and the cycle's
-id — plus one it does not: **the previous cycle**, which `--prev-cycle` supplies and
-which is otherwise read from the cycle records in the directories the memory system
-writes them to (`--cycles-log`, default `DEFAULT_CYCLES_LOGS` — the checkout's project
-memory root, plus one memory directory per session under it). A head pushed inside
-`[previous cycle's start, now)` is reported `abstain` instead of `vote` or `merge`.
-
-When the previous cycle cannot be found, `--cycle` is not silently ignored: the
-window shrinks to this cycle's own start, a `vote` row for an earlier push comes
-with the push time in view, and the queue prints what it could not determine. An
-unresolved window is never reported as a pass — the whole point of the clause is
-that the wrong direction is the one that spends a vote nobody can recount.
+(`cyc20260917-221117` began at 22:11:17 local). The near bound therefore needs no
+corpus at all: it is this cycle's own id. The far one does — **the cycle that follows
+it**, read from the cycle records in the directories the memory system writes them to
+(`--cycles-log`, default `DEFAULT_CYCLES_LOGS` — the checkout's project memory root,
+plus one memory directory per session under it). A head pushed inside `[this cycle's
+start, the next cycle's start)` is reported `abstain` instead of `vote` or `merge`.
+
+A cycle id that names no instant leaves the window unapplied, and the queue prints
+what it could not determine rather than passing it. An unresolved window is never
+reported as a pass — the whole point of the clause is that the wrong direction is the
+one that spends a vote nobody can recount.
 
 Exit codes
 ----------
@@ -164,7 +160,6 @@
 from dataclasses import dataclass, field, replace
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Iterator, Sequence
 
 REPO = "argszero/emrg"
 
@@ -261,15 +256,14 @@ def session_memory_roots(checkout: Path) -> tuple[Path, ...]:
 #: hold the ones written since a cycle put its record under the session it belongs to.
 #:
 #: **The direction of the error is why this is worth a paragraph.** The newest record
-#: decides the previous cycle, so a root that has stopped growing *freezes* the window
-#: at the last cycle that wrote there, and a frozen window is an over-wide one: heads
-#: pushed by the cycles in between are reported `abstain` when they are not one's own,
-#: and the cycles that pushed them lose a vote they were entitled to. Nothing is
+#: decides the far bound — the cycle that follows this one — so a root that has stopped
+#: growing *freezes* that bound at the last cycle that wrote there, and a frozen far
+#: bound is an *open* one: the span then has no upper end, so a head pushed by a cycle
+#: that followed is reported `abstain` when it is that later cycle's own work. Nothing is
 #: printed as a fault — the tool names a window, names the cycle it resolved and exits
-#: 0 — so only the row's cycle is wrong, and it is wrong in the permissive direction.
-#: Measured 2026-10-12: the project root's newest record was a day older than the
-#: newest record the session directories held, and the window was resolved from the
-#: stale one.
+#: 0 — so only the row's cycle is wrong. Measured 2026-10-12: the project root's newest
+#: record was a day older than the newest record the session directories held, and the
+#: bound was resolved from the stale one.
 #:
 #: This is the shape this tool carried while the prompt's record path moved once
 #: before (D9, PR #1555) and the corpus was split over two roots — it searched both
@@ -304,246 +298,6 @@ def resolve_cycle_logs(override: str | None = None) -> tuple[Path, ...]:
     return DEFAULT_CYCLES_LOGS
 
 
-# ── the dispatch corpus: the cycles the record corpus cannot see ──────────────
-#
-# Where a **dispatched** cycle leaves a trace even when it never reaches §4: one
-# `## Evolution Cycle` message per dispatch, in the task sessions' histories that sit
-# beside the cycle records under the same `.emrg` root.
-#
-# This corpus exists because the record one is written by the cycle itself, in its
-# final step, and a cycle that dies earlier writes nothing at all — so the record
-# corpus cannot tell "no cycle ran" from "a cycle ran and wrote no record". Issue
-# #2214 measured the consequence: `previous_cycle` then answers with the *older*
-# record, and the own-window widens silently over the missing cycle's work, which is
-# the direction that **blocks** a vote the clause would allow.
-#
-# What is read is the **cycle id the prompt carries**, never the line's timestamp. The
-# id is exact — it *is* the cycle's start — while a line's timestamp is a write instant
-# lagging it without a stated bound: over one host's 1793 dispatch lines, 1781 carry
-# their own id, and the gap between an id and the line holding it runs from 0.17 s to
-# 133 s (fourteen pairs above 5 s) against a 124 s minimum between two cycles. The two
-# ranges overlap, so a reading built on the timestamps cannot tell a late-written line
-# from a later cycle; the id decides it outright, and no threshold is fitted here.
-#
-# A session directory is not required, and its absence is not a failure: a checkout
-# shaped like CI's has no `.emrg/sessions/` at all, and the reading there is the one
-# the records alone give.
-#
-# The default follows the **records** rather than a constant of its own, so the two
-# corpora cannot be pointed at different roots: a record root `<...>/.emrg/memory` has
-# its dispatches in the `sessions` directory of the **same `.emrg` root**, and a
-# session's record root — the other scope a record root comes in — is owned by that
-# same root, so both answer with the one corpus instead of one real corpus and one
-# directory that never existed. A caller naming a corpus of its own (`--cycles-log`) is
-# answered from its own `.emrg` root, or from beside it when it has none — one
-# directory that is named, or absent.
-
-#: A dispatch marker, and the histories that hold one. Only the *line* has to be
-#: recognised cheaply, so the marker is matched as a substring before any parsing:
-#: a session history is the largest file this tool reads (11 MB on the host that
-#: measured it, and never compacted), and every line of it is a JSON object.
-_DISPATCH_MARK = "## Evolution Cycle"
-_HISTORY_NAME = re.compile(r"history(?:_\d{6})?\.jsonl")
-
-
-def sessions_root(record_root: Path) -> Path:
-    """The `sessions` directory of the `.emrg` root that owns a record directory.
-
-    A record's dispatch corpus sits in the `sessions` directory of the **same `.emrg`
-    root** as the record, and a record root comes in two scopes since D9 and #2221: the
-    project one (`.emrg/memory`) and a session's (`.emrg/sessions/<session>/memory`).
-    Looking beside the root answers that correctly for the first and invents nothing for
-    the second — `<session>/sessions` was never a corpus, but the derivation produced it
-    anyway, so the reading named a directory that does not exist as one it *could not
-    read* (issue #2222). Both scopes belong to the same `.emrg` root, so both answer with
-    the same directory and the difference disappears where it was introduced.
-
-    Without a `.emrg` ancestor the caller's own corpus is answered from **beside** it —
-    the convention the tests rely on to stay off the machine's real sessions
-    (`--cycles-log <tmp>/records` reads `<tmp>/sessions`), kept because a corpus of one's
-    own has no `.emrg` root to be found and no reason to be read from elsewhere.
-    """
-    for parent in Path(record_root).parents:
-        if parent.name == ".emrg":
-            return parent / "sessions"
-    return Path(record_root).parent / "sessions"
-
-
-def resolve_session_dirs(
-    override: str | None = None, cycles_logs: Sequence[Path] | None = None
-) -> tuple[Path, ...]:
-    """The session directories to read dispatches from.
-
-    The override (`--sessions-dir` / `$EMRG_SESSIONS_DIR`) wins; otherwise each record
-    root's own `.emrg` sessions directory (`sessions_root`), so the dispatches are read
-    from the same `.emrg` root as the records and there is no second constant to keep in
-    step — a caller that pointed `--cycles-log` at a corpus of its own is answered from
-    beside it, which is also what keeps a test off the machine's real sessions.
-
-    Duplicates collapse: the project root and every session root under one `.emrg` name
-    the same corpus, and a directory listed twice is a reading that looks like two.
-    """
-    raw = override or os.environ.get("EMRG_SESSIONS_DIR")
-    if raw:
-        return tuple(Path(part) for part in raw.split(os.pathsep) if part)
-    roots = tuple(cycles_logs) if cycles_logs else DEFAULT_CYCLES_LOGS
-    found: list[Path] = []
-    for root in roots:
-        candidate = sessions_root(Path(root))
-        if candidate not in found:
-            found.append(candidate)
-    return tuple(found)
-
-
-def dispatch_ids(dirs: Sequence[Path] | None = None) -> tuple[list[str], list[str]]:
-    """Every cycle id these sessions recorded as dispatched, oldest first, and what was unread.
-
-    One id per rendered evolution prompt, taken from the message that *is* the prompt:
-    the template substitutes the cycle's own id, so the line says which cycle it
-    dispatched. Duplicates collapse — a compacted `history.jsonl` and the daily file it
-    was compacted from hold the same dispatch, and a re-delivered prompt carries the id
-    it was first rendered with — and ids sort as time, so the caller can take the newest
-    one before its own.
-
-    A line is accepted only when it parses to a `message` whose role is `user`: the
-    marker is also a substring of anything that *quotes* a prompt (a tool result echoing
-    a history or the template, which is how this very file was measured), and an id read
-    off a quotation would attribute somebody else's dispatch to this corpus.
-
-    :param dirs: the session directories to read. `None` means the default.
-    :returns: `(ids, unreadable)` — the second names each directory or history that could
-        not be read, so a caller can tell "no dispatch is recorded here" from "the record
-        could not be read". An absent directory is named there too and is not an error: a
-        checkout with no sessions has no dispatches to offer, which is a state and not a
-        measurement that failed.
-    """
-    found: set[str] = set()
-    unreadable: list[str] = []
-    for directory in (resolve_session_dirs() if dirs is None else tuple(dirs)):
-        try:
-            sessions = sorted(entry for entry in directory.iterdir() if entry.is_dir())
-        except OSError as exc:
-            unreadable.append(f"{directory} ({exc.strerror or exc})")
-            continue
-        for session in sessions:
-            try:
-                histories = sorted(
-                    entry
-                    for entry in session.iterdir()
-                    if _HISTORY_NAME.fullmatch(entry.name)
-                )
-            except OSError as exc:
-                unreadable.append(f"{session} ({exc.strerror or exc})")
-                continue
-            for history in histories:
-                for line in _dispatch_lines(history, unreadable):
-                    try:
-                        record = json.loads(line)
-                    except ValueError:
-                        continue
-                    if record.get("type") != "message" or record.get("role") != "user":
-                        continue
-                    content = record.get("content") or ""
-                    if not isinstance(content, str):
-                        content = json.dumps(content)
-                    found.update(match.group(0) for match in _CYCLE_ID.finditer(content))
-    return sorted(found), unreadable
-
-
-#: The dispatch corpus, read at most once per process **per corpus**. A history is the
-#: largest file this tool reads (11 MB on the host that measured it) and the answer is a
-#: pure function of what is on disk, so a run that asks for the window once per vote -
-#: `check_pr` asks per voting cycle and `review-queue.py` asks once per PR - would pay the
-#: scan every time: 0.58 s, measured 2026-10-14 over 1802 ids. The key is the **resolved**
-#: dirs rather than the caller's argument, so two spellings of one corpus share an entry.
-#: A caller that writes to a corpus and re-reads it inside one process must clear this
-#: first; nothing in this tool does, and every test names a corpus of its own.
-_DISPATCHED_IDS: dict[tuple[str, ...], tuple[list[str], list[str]]] = {}
-
-
-def dispatched_ids(dirs: Sequence[Path] | None = None) -> tuple[list[str], list[str]]:
-    """`dispatch_ids`'s whole reading for one corpus, read once per process.
-
-    Both halves are cached and both are returned: the reading is a pure function of what
-    is on disk, so caching the ids alone made the caller re-read the corpus to learn
-    *why* an id was missing — which is the half that says whether a corpus was absent (a
-    state) or could not be read (a measurement that failed).
-    """
-    resolved = resolve_session_dirs() if dirs is None else tuple(dirs)
-    key = tuple(str(directory) for directory in resolved)
-    if key not in _DISPATCHED_IDS:
-        _DISPATCHED_IDS[key] = dispatch_ids(resolved)
-    ids, unreadable = _DISPATCHED_IDS[key]
-    return list(ids), list(unreadable)
-
-
-def corpus_read_failure(dirs: Sequence[Path], unreadable: Sequence[str]) -> str:
-    """The reason a dispatch corpus **that is there** could not be read (empty otherwise).
-
-    Membership is decided by the filesystem rather than by the error text: a corpus is
-    absent when nothing is at its path, which is the state a checkout shaped like CI's is
-    in and is not reported as a failure (issue #2216's acceptance), while a path that
-    holds something the reading could not open - a file where a directory was expected, a
-    directory that refused to list - leaves the ids incomplete and has to be said out
-    loud. `exists()` and not `is_dir()` for exactly that first case: a regular file at the
-    corpus path is not "absent", and it is not readable as a corpus either.
-
-    The test is applied **per entry, not to the set** (issue #2224's mixed case). A set that
-    holds one corpus that is there and one path that is not leaves the absent member's own
-    reason in `unreadable` - `dispatch_ids` records one, and its docstring says an absent
-    directory "is not an error" - so a set-level test passes on the present member and then
-    hands the *absent* one's reason back as the reason a corpus could not be read. Printed,
-    it says that a path with nothing at it failed to open, and "no dispatch was consulted
-    either" while the present corpus was walked. So the reasons kept are exactly those that
-    do not name an absent corpus directory.
-
-    The match is anchored at `"<path> ("`, the shape `dispatch_ids` writes, and not a bare
-    prefix: with `/tmp/a` absent and a file at `/tmp/ab`, `startswith("/tmp/a")` would drop
-    `/tmp/ab`'s genuine reason. In the other direction, a reason naming a **session**
-    directory or a **history** under a corpus is kept - it cannot be the absent member,
-    because `dispatch_ids` only descends into a directory that listed successfully.
-
-    **One overlap is left**, and it is silent rather than false: a reason string carries
-    its path's parentheses unescaped, so with `/tmp/a` absent and a file at `/tmp/a (copy)`
-    the *present* member's genuine reason starts with `"/tmp/a ("` too and is dropped with
-    the absent one (measured 2026-10-14, `cyc20261014-081405`). Master printed nothing for
-    that set either, so this is the reach of the disclosure and not a regression, and it
-    takes a corpus directory literally named `<another corpus> (…)` to arise. Closing it
-    needs the reasons **attributed to their directory by `dispatch_ids`** - the loop that
-    knows which member produced which - because an exact string comparison does not reach
-    both shapes: `reason.split(" (", 1)[0] == directory` fixes nothing here and reports an
-    *absent* directory whose own name carries a `" ("` as a corpus that failed to read.
-    `tests/test_review_queue.py::test_an_absent_corpus_is_never_disclosed_whatever_its_name_carries`
-    refuses that trade.
-    """
-    absent = tuple(str(directory) for directory in dirs if not Path(directory).exists())
-    return "; ".join(
-        reason
-        for reason in unreadable
-        if not any(reason.startswith(f"{directory} (") for directory in absent)
-    )
-
-
-def _dispatch_lines(history: Path, unreadable: list[str]) -> Iterator[str]:
-    """The lines of one history that hold a dispatch marker.
-
-    Reading line by line and matching before parsing is what keeps this affordable on
-    a file that grows without bound: the parse is paid only for the handful of lines
-    that can be a dispatch.
-
-    :param history: the history file to read.
-    :param unreadable: appended to when the file cannot be read.
-    :returns: the candidate lines, in file order.
-    """
-    try:
-        with history.open(encoding="utf-8", errors="replace") as handle:
-            for line in handle:
-                if _DISPATCH_MARK in line and '"role": "user"' in line:
-                    yield line
-    except OSError as exc:
-        unreadable.append(f"{history} ({exc.strerror or exc})")
-
-
 # ── the abstention window ────────────────────────────────────────────────────
 #
 # "May this cycle vote here?" has two halves. The counter owns the first — how many
@@ -585,67 +339,13 @@ def instant(text: str) -> datetime | None:
     return parsed if parsed.tzinfo else parsed.replace(tzinfo=timezone.utc)
 
 
-def previous_cycle(cycle: str, cycles_logs) -> tuple[str, str, str]:
-    """`(the cycle immediately before `cycle`, where it was found, why the corpus fell short)`.
-
-    The newest cycle record whose id sorts before this cycle's; ids are fixed width,
-    so string order is time order, and a file's `<date>-<time>` stem is turned back
-    into an id here because the filename does not carry the `cyc` prefix. The default
-    is several directories (`DEFAULT_CYCLES_LOGS`: the project memory root and one per
-    session); a caller may name several too, and the newest record wins *across* them —
-    which is the only reading that is right when the writers do not all use one root.
-
-    `("", reason, ...)` when there is none — an unresolvable window is the one input this
-    reading must not invent, because inventing it spends a vote. A directory that
-    cannot be read is named in the answer rather than passed over: an answer drawn
-    from the readable half is still an answer, but a reader has to know which half
-    it came from.
-
-    The third element is that half, **structurally**, and it is the difference between two
-    answers `where` renders in the same kind of words (issue #2275): "no cycle record
-    before this cycle" is a **measurement** — the corpus was listed and holds no earlier
-    record — while a root that could not be listed at all leaves the boundary
-    *unmeasured*, and a boundary nobody measured must not be replaced by the narrower
-    reading that credits a vote. So it is the reasons of the roots that were **not
-    listed** (an absent path and an unreadable one alike: neither answered), joined with
-    `'; '`, and `""` only when every named root was listed. A root that was listed and
-    merely holds nothing is not a shortfall — that is the case that legitimately narrows
-    the window, and `tests/test_check_vote_count.py`'s fixture is built on it.
-
-    A caller that named **no** root gets a shortfall too, which is the same fact
-    (`"no cycle-record directory was named"`): nothing was measured, so nothing may be
-    narrowed off.
-    """
-    logs = tuple(Path(entry) for entry in (cycles_logs or ()))
-    if not logs:
-        return "", "no cycle-record directory was named", "no cycle-record directory was named"
-    found, unreadable = _cycle_record_ids(cycles_logs)
-    named = ", ".join(str(log) for log in logs)
-    shortfall = "; ".join(unreadable)
-    if not found:
-        if len(unreadable) == len(logs):
-            return "", f"{shortfall} could not be read", shortfall
-        detail = f" ({shortfall} could not be read)" if unreadable else ""
-        return "", f"no cycle record before {cycle} in {named}{detail}", shortfall
-    earlier = sorted(entry for entry in found if entry < cycle)
-    where = (
-        str(found[earlier[-1]])
-        if earlier
-        else f"no cycle record before {cycle} in {named}"
-    )
-    if unreadable:
-        where += f" ({shortfall} could not be read)"
-    return (earlier[-1], where, shortfall) if earlier else ("", where, shortfall)
-
-
 def _cycle_record_ids(cycles_logs) -> tuple[dict[str, Path], list[str]]:
     """Every cycle id the record corpus holds, and the roots that were **not listed**.
 
-    The one scan both boundary resolvers read — `previous_cycle` takes the newest id below
-    this cycle's, `following_cycle` the earliest id above it — because a window is one span
-    and its two ends must see the same corpus. Resolved from two separate readings of the
-    roots, the same head reads one way in the queue and another at the poster, which is the
-    divergence this family has already paid for once (issue #2218).
+    The scan `following_cycle` reads for the window's far bound: the earliest id above this
+    cycle's. Resolved from a second reading of the roots, the same head would read one way in
+    the queue and another at the poster, which is the divergence this family has already paid
+    for once (issue #2218).
 
     A root that cannot be listed is *named* rather than passed over: an answer drawn from
     the readable half is still an answer, but a reader has to know which half it came from.
@@ -676,8 +376,8 @@ def following_cycle(cycle: str, cycles_logs) -> tuple[str, str, str]:
 
     `("", reason, ...)` when there is none — the *ordinary* state here rather than an
     accident: the newest cycle is the one posting a vote and nothing follows it yet, so its
-    span stays open at the far end. The third element keeps `previous_cycle`'s meaning (the
-    roots that were not listed), and its direction is the safe one: a corpus nobody could
+    span stays open at the far end. The third element is the roots that were **not listed**,
+    and its direction is the safe one: a corpus nobody could
     read has not said there is no later cycle either, so the bound stays open, which leaves
     the window **wide** — a delay, never a vote credited.
     """
@@ -687,14 +387,21 @@ def following_cycle(cycle: str, cycles_logs) -> tuple[str, str, str]:
     later = sorted(entry for entry in found if entry > cycle)
     if later:
         where = str(found[later[0]])
+        if unreadable:
+            where += f" ({shortfall} could not be read)"
+    elif unreadable and not found:
+        # Nothing at all could be listed, so "no cycle record after X" is a claim the
+        # corpus never supported: the reason is the read failure. The two are different
+        # facts and only one of them is a gap in the record corpus.
+        where = f"{shortfall} could not be read"
     else:
         where = (
             f"no cycle record after {cycle} in {named}"
             if named
             else "no cycle-record directory was named"
         )
-    if unreadable:
-        where += f" ({shortfall} could not be read)"
+        if unreadable:
+            where += f" ({shortfall} could not be read)"
     return (later[0], where, shortfall) if later else ("", where, shortfall)
 
 
@@ -702,45 +409,20 @@ def following_cycle(cycle: str, cycles_logs) -> tuple[str, str, str]:
 class Window:
     """The span of cycles whose heads this cycle must neither vote on nor merge.
 
-    `start` is the earliest push instant that counts as one's own; no `start` means
-    the clause could not be applied at all. `unresolved` names what is missing, so a
-    window shrunk to this cycle alone can say so rather than reading as the full one.
-
-    `inferred` says the boundary was **read off the cycle records** rather than named
-    by the caller, *and* that no second corpus was able to confirm it, and that is a
-    different kind of answer: a cycle that ran without writing a record has no record to
-    be found, so the window lands on the record *before* it instead - wider than the
-    clause says, silently, because a missing record and a cycle that never ran look
-    identical from there (issue #2214). `dispatch_ids`/`with_dispatches` clear the flag
-    where the session histories reach the boundary (issue #2216), so what it marks is
-    the state the records alone leave: the gap is real or unverifiable, never confirmed
-    otherwise. `previous` keeps the id the boundary was read from, so the reading can
-    name it.
-
-    `dispatch_unread` names a dispatch corpus that **is there and could not be read**,
-    which is a third answer and not the same one as an absent corpus: a checkout shaped
-    like CI's has no sessions and that is a state, while a corpus that exists and failed
-    to open leaves the ids *incomplete* — so the clause must not say no dispatch names
-    the cycle when a dispatch may sit in a file nobody could read.
-
-    `corpus_shortfall` is the same fact about the **record** corpus — the roots that
-    were not listed, absent ones included, because neither answered — and on this window
-    it is not a qualification but a **limit on what the window decided** (issue #2275):
-    the narrowed window's `start` is this cycle's own id, which no corpus supplies, while
-    its far end is the previous cycle's, which only the records answer. So a corpus that
-    could not be listed leaves that boundary unmeasured, and `boundary_unmeasured` is the
-    one producer of that reading — the counter asks it before it credits a vote whose
-    push falls below `start`, and the poster asks it before it posts one. It stays on the
-    window once resolved so the reading keeps saying which corpus fell short.
+    `start` is this cycle's own run start — a cycle id **is** its start instant — and
+    `end` is the instant the **next** cycle began, or `None` while this cycle is the
+    newest. The span is `[start, end)`: a head pushed before `start` belongs to somebody
+    else, so the vote counts, and one pushed from `end` onward belongs to the cycle that
+    followed (issue #2334).
+
+    No `start` means the clause could not be applied at all — the caller's cycle id names
+    no instant — and `unresolved` names that, so a window that was not applied says so
+    rather than reading as an empty one.
     """
 
     start: datetime | None = None
     source: str = ""
     unresolved: str = ""
-    previous: str = ""
-    inferred: bool = False
-    dispatch_unread: str = ""
-    corpus_shortfall: str = ""
     #: The far bound of the span: the instant the **next** cycle started, or `None` while
     #: this cycle is the newest — its run has not ended, which is the state every cycle is
     #: in when it posts a vote. A head pushed at or after this instant was pushed by that
@@ -758,10 +440,16 @@ def covers(self, pushed: datetime) -> bool:
         The clause is about a head **this** cycle pushed, and a cycle's run ends where the
         next cycle begins: the span is `[start, end)`, with `end` open while this cycle is
         the newest — nothing after it exists to take the run over, so every push since its
-        start is its own. The reason a far bound is needed at all is that without one the
-        span reaches *forward* without limit, and a head pushed by a later cycle was
-        reported as this one's own work (issue #2334: `cyc20261016-181619` was voided on a
-        head `cyc20261016-183420` pushed).
+        start is its own. A push *before* `start` was pushed by somebody else, and that is
+        the reading the host ruled for on 2026-10-16T22:18:15: "I think the requirement
+        'nor one pushed by the cycle immediately before it' should not exist. That the
+        cycle that pushed it cannot vote is already enough" (translated from the Chinese
+        original). So the window is this cycle's own run, not the previous cycle's too.
+
+        The far bound is needed because without one the span reaches *forward* without
+        limit, and a head pushed by a later cycle was reported as this one's own work
+        (issue #2334: `cyc20261016-181619` was voided on a head `cyc20261016-183420`
+        pushed).
 
         One predicate, asked by all three carriers — the queue that prints the verdict,
         the counter that voids a posted vote, the poster that refuses to spend one — so
@@ -771,24 +459,6 @@ def covers(self, pushed: datetime) -> bool:
             return False
         return pushed >= self.start and (self.end is None or pushed < self.end)
 
-    @property
-    def boundary_unmeasured(self) -> bool:
-        """Was the boundary the clause asks about ever measured?
-
-        `False` for a window whose far end a corpus answered — either the records (a
-        record was found for the cycle before this one) or the dispatch corpus (a
-        dispatched id reached the boundary, which clears `unresolved` and is exact, since
-        a cycle's id *is* its start). `True` only where the record corpus could not be
-        listed **and** nothing reached that boundary. The narrowed window is still
-        sound where it decided something: a push at or after its `start` (this cycle's own
-        id) is inside **every** candidate window, so `abstain` there is right. A push
-        *before* `start` is the one the wider window would have decided — the boundary it
-        needed, the start of the cycle before this one, is earlier than `start` and comes
-        from the records alone — and no reader may report a decision nobody took (issue
-        #2275).
-        """
-        return bool(self.corpus_shortfall and self.unresolved)
-
     def window_start_text(self) -> str:
         """The window's start as one readable instant (empty when unapplied)."""
         return self.start.isoformat(timespec="seconds") if self.start else ""
@@ -803,312 +473,66 @@ def window_end_text(self) -> str:
         """
         return self.end.isoformat(timespec="seconds") if self.end else ""
 
-    def inferred_clause(self) -> str:
-        """The sentence a records-only resolution owes its reader (empty otherwise).
-
-        One producer for both tools that act on a window: `review-queue.py` prints it as
-        its note and `cast-vote.py` appends it to the refusal a window produced, because
-        the two readings differ and the disclosure does not - a widened window makes the
-        report say `abstain` where a narrower one says `vote`, *and* makes the poster
-        refuse a vote the narrower window would have posted.
-        """
-        if not self.inferred:
-            return ""
-        named = f", the start of {self.previous}" if self.previous else ""
-        # What closes the gap is a *read* dispatch corpus, so the clause has to say
-        # which of the two states it is in rather than assume the good one. A corpus that
-        # is there and could not be read is the case this family treats as loudly as any
-        # other: the ids come back incomplete, so "no dispatch names it" is a claim about
-        # files nobody opened (issue #2224).
-        if self.dispatch_unread:
-            consulted = (
-                "The dispatch corpus could not be read "
-                f"({self.dispatch_unread}), so no dispatch was consulted either, and this "
-                "window reaches further back than the clause does - a head pushed inside "
-                "such a gap reads `abstain` where it would have been votable"
-            )
-        else:
-            consulted = (
-                "A cycle that ran and wrote no record is not named there, so where no "
-                "dispatch names it either this window reaches further back than the "
-                "clause does - a head pushed inside such a gap reads `abstain` where it "
-                "would have been votable"
-            )
-        return (
-            "the own-window clause was read off the cycle records, not named by a "
-            f"caller: the window starts {self.window_start_text()}{named}. {consulted} "
-            "(issue #2214)"
-        )
 
+def abstain_window(cycle: str, following: str = "") -> Window:
+    """The window one cycle's own run defines: `[its start, the next cycle's start)`.
 
-def abstain_window(cycle: str, previous: str, where: str,
-                   inferred: bool = False, corpus_shortfall: str = "",
-                   following: str = "") -> Window:
-    """The window, from the previous cycle's id — or a narrower one that says so.
-
-    The previous cycle's start is preferred because it is the wider window: a head
-    pushed by the cycle immediately before this one is treated as one's own
-    (precedent `cyc20260917-125823`). Without it the scan shrinks to this cycle's own
-    start, which is a strictly weaker reading and must not be printed as the stronger
-    one.
-
-    `inferred` is the caller's own account of where `previous` came from: `True` when
-    it was looked up in the record corpus, `False` when the caller named it. It moves
-    the window's *reading* and not its extent — see `Window.inferred` for what a
-    record-only resolution cannot see.
-
-    `corpus_shortfall` is `previous_cycle`'s third element: the roots that were not
-    listed, or the fact that none was named. It changes the answer only when **no
-    earlier record was found**, and there it is decisive (issue #2275). Falling back to
-    this cycle's own start is a reading of the corpus — "listed, and it holds nothing
-    earlier" — and a corpus that could not be listed has not made that statement. The
-    two render in the same words (`where` says "no cycle record before …" in both),
-    which is how an unreadable corpus came to *credit* a vote the readable corpus voids:
-    `check-vote-count.py 2271 --cycle <id>` read the cycle id as a directory path, and
-    the window it narrowed to counted a vote cast inside the real window.
-
-    So with a shortfall and no `previous`, the window is left **unresolved** — no
-    `start` at all, which is the state both tools already treat as "this vote cannot be
-    counted" (`own_head_window`) and "this vote must not be posted"
-    (`cast-vote.py`'s refusal). That is the same direction the family takes for an
-    unresolvable cycle id, and the one the clause's own accounting prefers: a delay
-    costs less than a vote spent on a boundary nobody measured. A boundary that *was*
-    found is still used, shortfall or not — `previous_cycle` answers with the newest
-    record across every readable root, so a named root that could not be listed can
-    only have made that boundary too *early*, which is the wide direction.
-
-    **A resolved boundary stays a reading even beside a shortfall**, and a caller that
-    named its own boundary (`--prev-cycle`, `inferred=False`) is not second-guessed:
-    neither asked the records what only the records answer.
+    A cycle id **is** its start instant, so the near bound needs no corpus: the clause is
+    about a head *this* cycle pushed, and everything before its own start was pushed by
+    somebody else. The host ruled the older, wider reading away on 2026-10-16T22:18:15
+    ("I think the requirement 'nor one pushed by the cycle immediately before it' should
+    not exist. That the cycle that pushed it cannot vote is already enough" — translated
+    from the Chinese original) — a cycle abstained on any push from the *previous* cycle's
+    start onward, which is "any head pushed while this cycle ran", not "the head this cycle
+    pushed".
 
     `following` is the cycle *after* this one, and it closes the span at the far end: a
     head pushed from the next cycle's start onward was pushed by that cycle, not by this
-    one, so the clause has nothing to say about it (issue #2334). It is `""` for the newest
-    cycle — the state every posting cycle is in — and the span is then open above, which is
-    right: nothing has taken the run over yet.
+    one, so the clause has nothing to say about it (issue #2334). It is `""` for the
+    newest cycle — the state every posting cycle is in — and the span is then open above,
+    which is right: nothing has taken the run over yet.
+
+    A cycle id that names no instant is the one input this reading must not invent, so
+    the window is left **unresolved** — no `start` at all, the state both tools already
+    treat as "this vote cannot be counted" and "this vote must not be posted".
     """
     own = cycle_start(cycle)
-    start = cycle_start(previous)
-    # The far bound, and it is the cycle *after* this one rather than the one before: a
-    # cycle's run ends where the next cycle begins, so a push from that instant onward
-    # belongs to that later cycle (issue #2334). `""` — no later cycle — leaves the span
-    # open, which is the state this cycle is in while it is the one running.
     end = cycle_start(following)
-    if start is not None:
+    if own is None:
         return Window(
-            start=start,
+            start=None,
+            source="",
+            unresolved=f"{cycle!r} is not a cycle id",
             end=end,
-            source=f"previous cycle {previous}" + (f" ({where})" if where else ""),
-            previous=previous,
-            inferred=inferred,
-            corpus_shortfall=corpus_shortfall,
-        )
-    if own is not None:
-        # The narrowed window, and the one case where its two ends are not equally
-        # measured: `start` is this cycle's own id, which no corpus supplies, so a head
-        # pushed at or after it is inside **every** candidate window and `abstain` is
-        # sound. The far end — the cycle before this one — comes from the records, so
-        # where those could not be listed it was never measured, and the narrowed window
-        # is then no longer a statement about a head pushed *before* `start`: the wider
-        # window it stands in for would have decided that push, and only one direction of
-        # the comparison survives (issue #2275). Which is why the shortfall stays on the
-        # reading rather than being spent here: `boundary_unmeasured` is what the counter
-        # and the poster ask before they credit or post on this window, and a window that
-        # answered "votable" from an end nobody measured is the defect this closes.
-        return Window(
-            start=own,
-            end=end,
-            source=f"this cycle only (started {own.isoformat(timespec='seconds')})",
-            unresolved=(
-                f"{corpus_shortfall} could not be read, so the start of the cycle "
-                "before this one - the boundary the wider window uses, earlier than this "
-                f"cycle's own start ({own.isoformat(timespec='seconds')}) - was never "
-                f"measured: a head pushed before "
-                f"{own.isoformat(timespec='seconds')} may be inside the window this vote's "
-                "cycle treats as its own, and an end nobody measured is not passed "
-                "(issue #2275)"
-                if corpus_shortfall
-                else where or "the previous cycle was not determined"
-            ),
-            previous=previous,
-            inferred=inferred,
-            corpus_shortfall=corpus_shortfall,
-        )
-    return Window(start=None, source="", unresolved=where or f"{cycle!r} is not a cycle id",
-                  previous=previous, inferred=inferred,
-                  corpus_shortfall=corpus_shortfall, end=end)
-
-
-def with_dispatches(window: Window, cycle: str, dispatched: Sequence[str]) -> Window:
-    """The window, moved up to a dispatched cycle the record corpus does not hold.
-
-    `previous_cycle` reads records, and a cycle that ran and never reached its record
-    step leaves none — so the corpus answers with the *older* record and the window it
-    found is wider than the clause asks. Every head pushed in the gap is then reported
-    `abstain`: not a vote spent, but a vote **blocked**, and silently, because nothing in
-    the row says the boundary it used is the wrong one. Issue #2214, whose two examples
-    are exactly this shape.
-
-    The remedy is the other corpus's own answer rather than an estimate of it: a
-    dispatched cycle's id *is* its start, so the boundary is exact, and a window moved
-    here is the one a record at that position would have produced. Nothing is inferred
-    from the clock, which is what the timestamps in those same histories cannot support
-    — see `dispatch_ids`.
-
-    An id taken here cannot be one the records hold: `previous_cycle` answers with the
-    **newest** record before this cycle, so a record newer than the window's own would
-    have *been* the window. That is the whole reason the move is sound in one direction
-    only — a dispatched id older than the record the window came from is either that same
-    cycle's own dispatch or an older cycle's, and it changes nothing. Where a record
-    exists it is authoritative; the dispatch corpus is never allowed to drag a resolved
-    window backwards.
-
-    :param window: the window the records produced.
-    :param cycle: this cycle's id.
-    :param dispatched: every cycle id the session histories recorded as dispatched.
-    :returns: the window to use. Moved when the newest dispatched cycle before this one
-        started later than the record the window was resolved from — in which case the
-        source names that cycle and says why the records do not hold it — and with its
-        `inferred` flag **cleared** either way when the corpus reaches the boundary: an
-        id equal to the records' own answer confirms it, so the disclosure that answer
-        owes its reader is not owed (see the two cases below).
-    """
-    own = cycle_start(cycle)
-    if own is None or not dispatched:
-        return window
-    earlier = [entry for entry in dispatched if entry < cycle]
-    if not earlier:
-        return window
-    boundary = cycle_start(earlier[-1])
-    if boundary is None:
-        return window
-    if window.start is not None and boundary <= window.start:
-        # The corpus names no *later* cycle than the records did, and the two cases in
-        # that are different answers. An id **older** than the boundary does not reach
-        # the gap above it — a stale quotation, a re-delivered prompt of an older cycle
-        # — and leaves the window, and its caveat, exactly as the records gave them.
-        # An id *equal* to the boundary is the **same cycle the records answered with**,
-        # and that confirms it: the gap this file's note is about is a cycle the daemon
-        # dispatched, so a corpus that was read and names no later one has nothing to
-        # disclose. Without this second case the note would print on every run of a
-        # checkout that has a session corpus — the ordinary shape here, measured
-        # 2026-10-13 while resolving issue #2216: 1798 dispatched ids, the newest the
-        # record's own answer — which is how a caveat that matters gets skimmed.
-        if window.boundary_unmeasured:
-            # The third case, and the one neither of the above answers: this window is the
-            # **narrowed fallback** (`abstain_window` found no record *and* the corpus could
-            # not be listed), so "exactly as the records gave them" says nothing about it —
-            # no record answered at all. A dispatched id *is* the boundary the records owed
-            # (`cycle_start` of the cycle before this one), so adopting it here does not
-            # drag a resolved window backwards; it supplies the measurement that was
-            # missing. It is also the **wider** window, earlier than this cycle's own start,
-            # and that is the point of taking it: without it the narrowed window can only
-            # abstain on a push below its start, which is a *delay* — while the counter's
-            # and the poster's `boundary_unmeasured` refusal is what stands in the meantime.
-            # A dispatch corpus that reached this boundary has answered the question the
-            # records could not, so the window stops saying an end nobody measured is
-            # undecided (issue #2275).
-            return Window(
-                start=boundary,
-                source=(
-                    f"previous cycle {earlier[-1]} (dispatched; the record corpus could "
-                    f"not be read ({window.corpus_shortfall}))"
-                ),
-                unresolved="",
-                previous=earlier[-1],
-                corpus_shortfall=window.corpus_shortfall,
-                # Both exits here build a **fresh** window rather than a `replace`, so
-                # every field the constructor is not handed is dropped silently. The far
-                # bound is not a function of the boundary being moved — the next cycle's
-                # start is the same fact either way — so it is carried (issue #2334).
-                end=window.end,
-            )
-        if boundary == window.start:
-            return replace(window, inferred=False)
-        return window
-    from_records = (
-        f"the newest record is {window.start.isoformat(timespec='seconds')}"
-        if window.start is not None
-        else (
-            f"the record corpus could not be read ({window.corpus_shortfall}), so this "
-            "boundary is the dispatch corpus's own answer"
-            if window.corpus_shortfall
-            else "no cycle record exists before this cycle"
         )
-    )
     return Window(
-        start=boundary,
-        source=f"previous cycle {earlier[-1]} (dispatched, no cycle record; {from_records})",
-        unresolved="",
-        previous=window.previous,
-        corpus_shortfall=window.corpus_shortfall,
-        # The far bound moves with the window and not with its start: `boundary` is a
-        # dispatched cycle *before* this one, so it cannot be at or past `end`, which is
-        # the cycle *after* this one. Dropping it here would put the span back to having
-        # no far end, which is the defect `end` exists to close (issue #2334).
-        end=window.end,
+        start=own,
+        end=end,
+        source=f"this cycle's own run (started {own.isoformat(timespec='seconds')})",
     )
 
 
-def own_window(
-    cycle: str,
-    prev_cycle: str | None = None,
-    cycles_log: str | None = None,
-    sessions_dir: str | None = None,
-) -> Window:
-    """The own-window, resolved from **both** corpora — the single producer for a rule
-    three tools act on.
-
-    `previous_cycle` answers from the records and `with_dispatches` moves that boundary
-    up past a cycle the daemon dispatched and that reached no record (issue #2216),
-    while `inferred` carries the disclosure a records-only resolution owes its reader
-    (issue #2214). The three compose **here and nowhere else**, because a window is a
-    rule and not an implementation detail: `review-queue.py` prints the verdict from it,
-    `cast-vote.py` refuses to *post* on it, and `check-vote-count.py` voids a posted
-    vote on it. Resolved from the records alone in one carrier and from both in another,
-    the same head reads `vote` in the queue and is refused at the poster — a vote lost
-    to an arithmetic difference between two carriers rather than to the clause (issue
-    #2218; measured 2026-10-14: the records-only boundary is too early for **20** of the
-    corpus's **350** cycle records, so a head pushed in such a gap is abstained *later*
-    than the clause asks, or refused a vote it was entitled to post).
-
-    `prev_cycle` is the caller's own answer (`--prev-cycle`) and the dispatches are not
-    consulted for it: a caller that named its boundary asked a different question, and
-    the note about a cycle the records cannot see is not owed to one that never asked
-    the records. It is also not *second-guessed*, which is the reading `--prev-cycle`
-    has always had.
+def own_window(cycle: str, cycles_log: str | None = None) -> Window:
+    """The own-window — the single producer for a rule three tools act on.
+
+    The near bound is this cycle's own start (`abstain_window`); the far one is the cycle
+    that follows it, resolved from the record corpus because a later cycle's existence is
+    a fact only the records hold. The two compose **here and nowhere else**, because a
+    window is a rule and not an implementation detail: `review-queue.py` prints the
+    verdict from it, `cast-vote.py` refuses to *post* on it, and `check-vote-count.py`
+    voids a posted vote on it. Resolved from different corpora in different carriers, the
+    same head reads `vote` in the queue and is refused at the poster — a vote lost to an
+    arithmetic difference between two carriers rather than to the clause (issue #2218).
 
     :param cycles_log: the cycle-record corpus, `os.pathsep`-joined for several, or
         `None` for the default roots.
-    :param sessions_dir: the dispatch corpus, or `None` for `$EMRG_SESSIONS_DIR`, else
-        the `sessions` directory of the `.emrg` root each record root belongs to
-        (`sessions_root`) — so naming a corpus of one's own points both at *it*, and
-        the two cannot drift apart.
-    :returns: the window to use. `inferred` is cleared when the dispatch corpus reaches
-        the boundary the records gave, since an id equal to that boundary confirms it;
-        it also stays clear when `prev_cycle` named the boundary.
+    :returns: the window to use.
     """
     roots = resolve_cycle_logs(cycles_log)
-    # The far bound is resolved for **every** caller, `--prev-cycle` included. Naming the
-    # lower boundary says which question the caller asked about the *start*; the span's
-    # other end is a fact of the corpus either way, and a caller that named its start did
-    # not thereby claim the run of every cycle that followed it (issue #2334).
-    following, _following_where, _following_shortfall = following_cycle(cycle, roots)
-    if prev_cycle:
-        # The caller's own answer, taken as named: a caller that named its boundary asked
-        # a different question from one that asked the records, and the dispatches are
-        # not consulted for it.
-        return abstain_window(cycle, prev_cycle, "named by --prev-cycle", inferred=False,
-                              following=following)
-    previous, where, shortfall = previous_cycle(cycle, roots)
-    window = abstain_window(cycle, previous, where, inferred=True,
-                            corpus_shortfall=shortfall, following=following)
-    corpora = resolve_session_dirs(sessions_dir, roots)
-    ids, unreadable = dispatched_ids(corpora)
-    return replace(
-        with_dispatches(window, cycle, ids),
-        dispatch_unread=corpus_read_failure(corpora, unreadable),
-    )
+    # The far bound is read for every caller: it is a fact of the corpus, and a window
+    # whose far end nobody looked for would report a later cycle's head as this one's own.
+    following, _where, _shortfall = following_cycle(cycle, roots)
+    return abstain_window(cycle, following=following)
 
 
 def _sibling(name: str, module_name: str):
@@ -1470,8 +894,8 @@ def read_pr(pr: int, repo: str = REPO, cycle: str | None = None,
     is passed through to the counter, which is the tool that owns the refusal: this
     one neither softens it nor invents a verdict if the budget runs out. `cycles_log`
     goes through for the same reason the flag exists: the counter reads the abstention
-    window out of it, so a corpus named here and not there would have this row's window
-    read from one collection of cycles and its *count* judged against another.
+    window's far bound out of it, so a corpus named here and not there would have this
+    row's window read from one collection of cycles and its *count* judged against another.
     """
     out = Reading(pr=pr, head="", needed=needed)
 
@@ -1776,40 +1200,10 @@ def next_action(reading: Reading, cycle: str | None = None, repo: str = REPO,
         if pushed is not None and window.covers(pushed) and not other_pusher:
             return Action(
                 kind="abstain",
-                why=f"head pushed {reading.head_pushed_at}, inside the window this cycle "
+                why=f"head pushed {reading.head_pushed_at}, inside the run this cycle "
                     f"treats as its own ({window.source}) - a cycle neither votes on nor "
-                    "merges a head it pushed, and the window immediately before this one "
-                    "counts as one's own as well, because every cycle on a host is the same "
-                    "instance running again; the next vote here (and the merge) has to come "
-                    f"from a later cycle; {decided}",
-                command=f"{RUNNER} scripts/check-vote-count.py {pr}",
-            )
-        if (
-            pushed is not None
-            and pushed < window.start
-            and window.boundary_unmeasured
-            and not other_pusher
-        ):
-            # The other half of the same defect (issue #2275), and the half the row above
-            # cannot reach: this push is *below* the narrowed start, so the widened window
-            # is the one that decides it - and that window's far end was never measured,
-            # because the record corpus could not be listed. A row saying `vote` here
-            # invites a vote the poster refuses and the counter voids, which is the class
-            # this family keeps fixing: the remedy has to be right for its own cause. So
-            # the row reports the abstention the unmeasured boundary imposes, and names
-            # the corpus to pass rather than a command that would spend nothing but time.
-            return Action(
-                kind="abstain",
-                why=f"head pushed {reading.head_pushed_at}, before the window this cycle "
-                    f"treats as its own ({window.source}), and the boundary above it was "
-                    "never measured - the start of the cycle before this one is the "
-                    f"boundary the wider window uses, and the record corpus could not be listed "
-                    f"({window.corpus_shortfall}), so whether this push falls inside the "
-                    "window the clause asks about cannot be decided from here; a boundary "
-                    "nobody measured is not passed, because the narrowed window below it "
-                    "would credit a vote cast inside the one that was never read - pass "
-                    "`--cycles-log DIR` (or `--prev-cycle <id>`) to have the full window "
-                    f"applied; {decided}",
+                    "merges a head it pushed, so the next vote here (and the merge) has to "
+                    f"come from a later cycle; {decided}",
                 command=f"{RUNNER} scripts/check-vote-count.py {pr}",
             )
         if other_pusher and pushed is not None:
@@ -1880,8 +1274,8 @@ def rows(readings: list[Reading], cycle: str | None, repo: str,
 def window_note(window: Window | None) -> str:
     """What the report owes the reader about the own-window clause, before its rows.
 
-    Three states are readings of that clause the rows cannot show on their own, and each
-    of them moves a row that otherwise reads `vote`:
+    Two states are readings of that clause the rows cannot show on their own, and each of
+    them moves a row that otherwise reads `vote`:
 
     * **no `--cycle`** — the clause was not applied at all. The rows answer the count
       question and nothing else, so a `vote` here may be a head this very cycle pushed.
@@ -1893,50 +1287,23 @@ def window_note(window: Window | None) -> str:
       `--cycle` turned that row into `abstain`.
 
       The **cost, measured rather than carried over** — the vote itself is not spent:
-      `cast-vote.py` reads the cycle id out of the body, resolves the previous cycle
-      itself, and refuses with `own-head-window` (rc 2), which it did on that very head
-      in this cycle's probe. What the unflagged run costs is a **wrong reading**: the
-      first tool a cycle runs states `vote` where its own windowed answer is `abstain`,
-      and a reader who acts on the row — writing the body, planning the merge, reading
-      the state as "this head is votable" — has acted on a verdict the tool does not
-      hold. The backstop is downstream, one command later, and it arrives as a refusal
-      rather than as the `abstain` the report should have printed.
-
-      The docstring above has promised "it reports the first question only, and says so"
-      since the clause was written, and this line is that "so" — it had no carrier at
-      all before.
-    * **a window narrowed to this cycle alone** — the previous cycle could not be read,
-      so a head *it* pushed is not reported as one's own. Already said, since
-      `test_an_unresolvable_previous_cycle_narrows_the_window_and_says_so`; what moves
-      is *where*, and the two notes move together because they are the same debt.
-    * **a window inferred from the records** (`window.inferred`) — the clause *was*
-      applied, and its extent is still not the one it claims, because the boundary was
-      looked up in the `cycle-*.md` records: a cycle that ran without writing one is not
-      found there, so the boundary lands on the record before it and the window reaches
-      further back than the clause does. The session histories' dispatch lines close that
-      gap where they are present (`dispatch_ids`/`with_dispatches`, which run first and
-      clear `inferred` both when they move the window and when they confirm it), so this
-      state is reached where that corpus is absent or empty — a checkout shaped like
-      CI's — or where the newest id it names is *older* than the record boundary and so
-      does not reach the gap. It
-      is the third state because it is the one silence read as a
-      pass for longest — the row says `abstain` and nothing else, and `abstain` here is
-      indistinguishable from `abstain` for a boundary that is right. Naming the instant
-      is what makes the width inspectable at all (issue #2214; the measurement is in the
-      code below). A boundary **named by the caller** (`--prev-cycle`) is not inferred
-      and prints nothing: the reader supplied it, so there is no resolution of the
-      tool's to disclose, and a note on every run is how the note that matters gets
-      skimmed — the control `test_a_windowed_run_prints_no_such_note` holds this half.
+      `cast-vote.py` reads the cycle id out of the body, resolves the window itself, and
+      refuses with `own-head-window` (rc 2), which it did on that very head in this
+      cycle's probe. What the unflagged run costs is a **wrong reading**: the first tool a
+      cycle runs states `vote` where its own windowed answer is `abstain`, and a reader
+      who acts on the row has acted on a verdict the tool does not hold.
+
+    * **a window with no start** — the cycle id given names no instant, so the clause was
+      not applied either, and every row is the count question alone.
 
     The placement is the point, and it is this family's convention rather than a
     preference: a caveat that follows the row it weakens is read after the reader has
     already acted on it. Printed first, it also survives `| head`, which the tail
     placement did not — a queue of eight PRs is ~40 lines, and the note was line 39.
 
-    Returns the note (empty when the clause was applied from a boundary the caller
-    named). Prose only: under `--json` the same facts are the documented
-    `vote_window_start` / `vote_window_source` pair, and a line ahead of the document
-    would break every machine consumer.
+    Returns the note (empty when the clause was applied). Prose only: under `--json` the
+    same facts are the documented `vote_window_start` / `vote_window_source` pair, and a
+    line ahead of the document would break every machine consumer.
     """
     if window is None:
         return (
@@ -1945,39 +1312,13 @@ def window_note(window: Window | None) -> str:
             "into `abstain`. Pass --cycle <this cycle's id> to have the clause applied."
         )
     if window.unresolved:
-        where = (
-            f"only pushes at or after {window.window_start_text()}"
-            if window.applied
-            else "and this cycle's own id could not be read, so the clause was not "
-                 "applied at all"
-        )
         return (
-            f"note: the abstention window could not be widened to the cycle before this "
-            f"one ({window.unresolved}) - {where} were checked. Pass --prev-cycle or "
-            "--cycles-log DIR to have the full window applied."
+            "note: the own-window clause was NOT applied - "
+            f"{window.unresolved}, so the run this cycle owns was never delimitated and a "
+            'row reading "vote" may be a head this cycle pushed. Pass --cycle with this '
+            "cycle's own id to have the clause applied."
         )
-    if not window.inferred:
-        return ""
-    # The window was read off the records, so it is one record's answer and not the
-    # cycle boundary it stands for. A cycle that ran and wrote no record - phase work
-    # then no §4 - leaves nothing for the resolver to find, and it lands on the record
-    # *before* it: wider than the clause, silently for the reader, because silence here
-    # is exactly how a full window reads. Measured 2026-10-13 (issue #2214): two such
-    # cycles in one day, the window starting at 17:17:21 where the cycle before it
-    # began at 19:46:08, and one head pushed at 19:32:47 inside that gap read `abstain`
-    # where it was votable. So the instant is printed even though the clause *was*
-    # applied - the fact being disclosed is where the boundary came from, which the
-    # row cannot show. What closes it is not the daemon's own
-    # `logs/task-runs/<task>.jsonl` - measured the same day, that log holds no entry
-    # for a cycle that ended in error - but the session histories' dispatch lines,
-    # which `dispatch_ids`/`with_dispatches` read: a dispatch names its cycle's own id,
-    # so a cycle the records miss is found there and this note is then not reached.
-    # So a reader still sees it only where that corpus is absent, empty, or names no
-    # cycle the records do not — never as "the gap cannot be closed".
-    return (
-        f"note: {window.inferred_clause()}. "
-        "Pass --prev-cycle <id> to name the boundary yourself."
-    )
+    return ""
 
 
 def render(reading: Reading, action: Action) -> str:
@@ -2207,33 +1548,14 @@ def main(argv: list[str] | None = None) -> int:
         help="this cycle's id (cycYYYYMMDD-HHMMSS); given, the queue also answers "
              "whether this cycle may still vote at each head",
     )
-    parser.add_argument(
-        "--prev-cycle",
-        default=None,
-        help="the cycle immediately before this one (cycYYYYMMDD-HHMMSS); a cycle id "
-             "is its start time, so this is the far end of the abstention window - a "
-             "head pushed by it counts as this cycle's own. Given, the boundary is "
-             "taken as named and the note that a records-only resolution cannot see a "
-             "cycle which wrote no record is not printed (issue #2214)",
-    )
     parser.add_argument(
         "--cycles-log",
         default=None,
-        help="directory of `cycle-<id>.md` records, used to find the previous cycle "
-             "when --prev-cycle is not given (default: $EMRG_CYCLES_LOG, else the "
+        help="directory of `cycle-<id>.md` records, read for the cycle that follows "
+             "this one - the window's far bound (default: $EMRG_CYCLES_LOG, else the "
              f"{os.pathsep}-joined directories the memory system writes records to: "
              f"{os.pathsep.join(str(d) for d in DEFAULT_CYCLES_LOGS)})",
     )
-    parser.add_argument(
-        "--sessions-dir",
-        default=None,
-        help="directory holding the task sessions whose histories record every cycle "
-             "dispatch, used to move the abstention window up to a cycle that ran and "
-             "wrote no record (default: $EMRG_SESSIONS_DIR, else the `sessions` "
-             "directory of the `.emrg` root each --cycles-log root belongs to). "
-             "Absent is not an error: a checkout shaped like CI's has none, and the "
-             "window is then the one the records alone give",
-    )
     parser.add_argument(
         "--min-votes",
         type=int,
@@ -2271,15 +1593,11 @@ def main(argv: list[str] | None = None) -> int:
 
     window: Window | None = None
     if args.cycle:
-        # Both halves of the own-window's answer, and they compose in exactly one place:
-        # the records resolve the boundary and say whether it was inferred or named
-        # (issue #2214), and the dispatches then move it up past a cycle that ran without
-        # writing a record (issue #2216). `own_window` owns the composition because the
-        # two sibling tools that act on the same window - `cast-vote.py` at the poster and
-        # `check-vote-count.py` at the counter - read it from there too (issue #2218).
-        window = own_window(
-            args.cycle, args.prev_cycle, args.cycles_log, args.sessions_dir
-        )
+        # The window composes in exactly one place: `own_window` owns both bounds - this
+        # cycle's own start and the start of the cycle that follows it - because the two
+        # sibling tools that act on the same window (`cast-vote.py` at the poster and
+        # `check-vote-count.py` at the counter) read it from there too (issue #2218).
+        window = own_window(args.cycle, args.cycles_log)
 
     try:
         queue = args.prs if args.prs else open_prs(args.repo)
diff --git a/tests/test_cast_vote.py b/tests/test_cast_vote.py
index c19b6a66..82427496 100644
--- a/tests/test_cast_vote.py
+++ b/tests/test_cast_vote.py
@@ -55,12 +55,21 @@
 OTHER_CYCLE = "cyc20260915-235900"
 ID_REVIEW = "emrg: a flag with an attached value is the same flag (#1256)"
 
-#: The cycle the abstention clause is measured against — one minute before `CYCLE`, the
-#: same shape `tests/test_review_queue.py` uses for the same clause, so the two files pin
-#: the same two ends. In UTC (`cycle_start` converts; a cycle id is local time): `CYCLE`
-#: starts at 18:01:49Z and this one at 17:59:06Z.
+#: The cycle the abstention clause is measured against — one minute before `CYCLE`. A
+#: cycle id *is* its local start time, and since 2026-10-16 the window's near bound is
+#: each cycle's **own** start, so a head this cycle pushed is refused and a head
+#: `PREV_CYCLE` pushed is not: the pair is what "whose work is this" is measured against.
+#: In UTC (`cycle_start` converts): `CYCLE` starts at 18:01:49Z and this one at 17:59:06Z.
 PREV_CYCLE = "cyc20260916-015906"
 
+#: A record corpus with **nothing** in it. The window's far bound is the cycle that
+#: follows this one, read from `--cycles-log`; left to the default this host's own records
+#: would give these 2026-09-16 ids a successor, closing the span at a machine-dependent
+#: instant. A path that does not exist answers "no cycle record after this cycle", which
+#: leaves the span open above — the state the posting cycle itself is in. Callers that
+#: exercise the corpus pass their own `--cycles-log`.
+NO_RECORDS = REPO_ROOT / "tests" / "_no_such_cycles_log"
+
 #: Where every head in this file was pushed unless the test moves it: **before both ends
 #: of the window**, so the clause lets the vote through and the tests that measure
 #: attribution and counting keep measuring exactly that. A test about the clause sits its
@@ -274,18 +283,17 @@ def write(text: str) -> str:
 
 
 def _run(mod, monkeypatch, counter: FakeCounter, gh: FakeGh, argv: list[str]):
-    """`main` with the counter, `gh` and the window's far end all pinned.
+    """`main` with the counter, `gh` and the window's far bound all pinned.
 
-    `--prev-cycle` is supplied unless the caller pins the window itself (with
-    `--prev-cycle` or `--cycles-log`). The tool's default is the cycle records beside the
-    checkout, so a test that let the default decide would be measuring this host's memory
-    directory rather than the clause — and would answer differently on CI, where those
-    records do not exist.
+    `--cycles-log` is supplied unless the caller pins the corpus itself. The tool's
+    default is the cycle records beside the checkout, so a test that let the default
+    decide would be measuring this host's memory directory rather than the clause — and
+    would answer differently on CI, where those records do not exist.
     """
     monkeypatch.setattr(mod, "votes_counter", lambda: counter)
     monkeypatch.setattr(mod, "_gh", gh)
-    if "--prev-cycle" not in argv and "--cycles-log" not in argv:
-        argv = [*argv, "--prev-cycle", PREV_CYCLE]
+    if "--cycles-log" not in argv:
+        argv = [*argv, "--cycles-log", str(NO_RECORDS)]
     return mod.main(argv)
 
 
@@ -1352,14 +1360,20 @@ def test_zero_is_a_supported_budget_and_asks_once(mod, monkeypatch, capsys, body
 
 # ── the abstention clause: whose head is this? (issue #1408) ───────────────
 #
-# The clause is *a cycle does not vote on a head it pushed*, and the cycle immediately
-# before this one counts as one's own. `review-queue.py` owns that reading and reports
-# such a head as `abstain`; these tests pin that the same reading is **enforced where the
-# vote is spent**, because the counter — the only authority on whether a vote counted —
-# never asks who pushed the head, and un-spending one afterwards is a hand edit of the
-# review body. Measured 2026-09-21 (`cyc20260921-114528`): a vote went out on a head
-# pushed inside the previous cycle's window, and the sibling reported `abstain` for that
-# same head minutes later.
+# The clause is *a cycle does not vote on a head it pushed*, and the run that counts is
+# **this cycle's own** — from its own start to the start of the cycle that follows it.
+# `review-queue.py` owns that reading and reports such a head as `abstain`; these tests
+# pin that the same reading is **enforced where the vote is spent**, because the counter —
+# the only authority on whether a vote counted — never asks who pushed the head, and
+# un-spending one afterwards is a hand edit of the review body. Measured 2026-09-21
+# (`cyc20260921-114528`): a vote went out on a head pushed inside the previous cycle's
+# window, and the sibling reported `abstain` for that same head minutes later.
+#
+# The wider reading — where the cycle immediately *before* this one also counted as one's
+# own — was struck out by the host on 2026-10-16T22:18:15 ("I think the requirement 'nor
+# one pushed by the cycle immediately before it' should not exist. That the cycle that
+# pushed it cannot vote is already enough" — translated from the Chinese original). The
+# pair of tests below measures the boundary that moved.
 #
 # Every push below is named in the host's zone through `_push`, so the two ends of the
 # window are the same two ends on a +08 host, a +04 one and a UTC one. A bare `...Z`
@@ -1368,23 +1382,27 @@ def test_zero_is_a_supported_budget_and_asks_once(mod, monkeypatch, capsys, body
 # Every refusal's **direction** is asserted, not just its occurrence: nothing was posted.
 # Mutation arm, run 2026-09-21 and reported in the cycle record `cyc20260921-114528`:
 # reversing the comparison in `own_head_window` (`pushed >= window.start` -> `<`) turns
-# the three refusals that decide from the push time red (the previous cycle's head, the
-# boundary, the narrowed window) and leaves the negative control green — which is what
-# says the control is a real one.
+# the refusals that decide from the push time red (the boundary, the narrowed window) and
+# leaves the negative control green — which is what says the control is a real one.
 
 
-def test_a_head_the_previous_cycle_pushed_is_refused_before_anything_is_posted(
+def test_a_head_inside_this_cycles_run_is_refused_before_anything_is_posted(
     mod, monkeypatch, capsys, body_file
 ):
-    """The measured violation: a vote went out, and the sibling said `abstain` for it.
-
-    The head below is pushed a minute inside the window the cycle before `CYCLE` opened
-    (01:59:06 local), and before `CYCLE` itself began. `check-vote-count.py` counts a
-    vote here — it reads *when* a vote was cast, never *who pushed the head* — so nothing
-    else in this toolchain objects, which is exactly why the check has to be here.
+    """The clause, at the boundary that moved with the host's ruling of 2026-10-16T22:18:15.
+
+    The head below is pushed a minute inside the run of the cycle *before* `CYCLE`
+    (01:59:06 local) and before `CYCLE` itself began. The older reading refused it —
+    "nor one pushed by the cycle immediately before it" — and the host struck that
+    requirement out, so the push belongs to whoever made it and the vote goes out. The
+    test named for the refusal keeps the *other* side of the same edge, one minute later:
+    `test_the_window_is_closed_at_this_cycles_own_start`.
     """
     pushed = _push(2026, 9, 16, 2, 0, 0)
-    counter = FakeCounter(verdict_with(push_time=pushed))
+    counter = FakeCounter(
+        verdict_with(push_time=pushed),
+        verdict_with([vote()], counted=[True], valid_count=1),
+    )
     gh = FakeGh()
     rc = _run(
         mod,
@@ -1393,29 +1411,21 @@ def test_a_head_the_previous_cycle_pushed_is_refused_before_anything_is_posted(
         gh,
         ["1255", "--body-file", body_file(f"{CYCLE} — ✅ LGTM")],
     )
-    err = capsys.readouterr().err
-    assert rc == 2, "nothing was posted, so nothing has to be rolled back"
-    assert gh.calls == [], "the clause exists to prevent the post, not to report it"
-    assert counter.calls == [(1255, 3)], (
-        "one read, and it is the one whose verdict carries the push time the clause "
-        "decides from"
-    )
-    assert "inside the window this cycle treats as its own" in err
-    assert PREV_CYCLE in err, "the window's source is named, not implied"
-    assert pushed in err, "the push time that decided it is quoted back"
-    assert "abstain" in err, "the reader must learn where the same head is reported"
-    assert "later cycle" in err, "and what the remedy is: another cycle's vote"
+    out = capsys.readouterr().out
+    assert rc == 0, "the push predates this cycle's own run, so it is not this cycle's work"
+    assert len(gh.calls) == 1 and gh.calls[0][:3] == ["pr", "review", "1255"]
+    assert "counted" in out
 
 
-def test_the_window_is_closed_at_its_start(mod, monkeypatch, capsys, body_file):
-    """A push *at* the previous cycle's start is inside it — the boundary `review-queue`
-    pins for the same clause, from the same `abstain_window`.
+def test_the_window_is_closed_at_this_cycles_own_start(mod, monkeypatch, capsys, body_file):
+    """A push *at* this cycle's own start is inside its run — the boundary `review-queue`
+    pins for the same clause, from the same `own_window`.
 
     An exclusive start would be a one-second hole in a rule that has no other edge, and
     it is the edge a refresh lands on: a cycle merges master and the merge commit's time
     is the instant its window begins.
     """
-    pushed = _push(2026, 9, 16, 1, 59, 6)
+    pushed = _push(2026, 9, 16, 2, 1, 49)  # `CYCLE`'s own start, in the host's zone
     counter = FakeCounter(verdict_with(push_time=pushed))
     gh = FakeGh()
     rc = _run(
@@ -1428,7 +1438,7 @@ def test_the_window_is_closed_at_its_start(mod, monkeypatch, capsys, body_file):
     err = capsys.readouterr().err
     assert rc == 2
     assert gh.calls == []
-    assert "inside the window" in err and pushed in err
+    assert "inside the run this cycle treats as its own" in err and pushed in err
 
 
 def test_the_negative_control_a_push_before_the_window_is_still_posted(
@@ -1441,7 +1451,7 @@ def test_the_negative_control_a_push_before_the_window_is_still_posted(
     unable to let anything through.
     """
     counter = FakeCounter(
-        verdict_with(push_time=_push(2026, 9, 16, 1, 59, 5)),
+        verdict_with(push_time=_push(2026, 9, 16, 2, 1, 48)),
         verdict_with([vote()], counted=[True], valid_count=1),
     )
     gh = FakeGh()
@@ -1519,270 +1529,16 @@ def test_a_head_with_no_ci_run_cannot_be_judged_so_nothing_is_posted(
     )
 
 
-def test_a_corpus_that_cannot_be_listed_refuses_before_anything_is_posted(
-    mod, monkeypatch, capsys, body_file, tmp_path
-):
-    """Issue #2275 at the poster: a boundary nobody measured is not a boundary.
-
-    `--cycles-log` is named and `--prev-cycle` is not, so the window is resolved exactly as
-    the counter resolves it for a vote it counts (`review-queue.own_window` — one producer,
-    both readers). A root that can be **listed** and holds no earlier record is a
-    measurement: the clause narrows to this cycle's own start and the vote goes out (the
-    control below, and the reading the defect let through). A root that could not be listed
-    answers nothing, so there is no boundary to narrow — and this tool must stop on
-    `not window.applied` rather than post under the narrow one, which is the same branch
-    `own_head_window` keys on when it marks such a vote `VOID`.
-    """
-    path = body_file(f"{CYCLE} \u2014 \u2705 LGTM")
-    listed = tmp_path / "listed-and-empty"
-    listed.mkdir()
-
-    # (a) the control: listed, and it holds nothing earlier — a measurement, so the narrow
-    #     window stands and the vote is posted
-    control_gh = FakeGh()
-    rc = _run(
-        mod, monkeypatch,
-        FakeCounter(verdict_with(),
-                    verdict_with([vote()], counted=[True], valid_count=1)),
-        control_gh,
-        ["1255", "--cycles-log", str(listed), "--body-file", path],
-    )
-    _out, err = capsys.readouterr()
-    assert rc == 0, f"a listed corpus is a measured window, so the vote goes out: {err}"
-    assert control_gh.calls, "the control must actually post"
-
-    # (b) the same argv against a root that cannot be listed: no window, so no post
-    gh = FakeGh()
-    rc = _run(
-        mod, monkeypatch, FakeCounter(verdict_with()), gh,
-        ["1255", "--cycles-log", str(tmp_path / "gone"), "--body-file", path],
-    )
-    err = capsys.readouterr().err
-    assert gh.calls == [], "a vote must not be posted on a window nobody measured"
-    assert rc == 2
-    assert "could not be read" in err and "2275" in err, err
-
-
-def test_the_previous_cycle_is_read_from_the_cycle_records(
-    mod, monkeypatch, capsys, body_file, tmp_path
-):
-    """`--cycles-log`: the newest record that sorts *before* this cycle's id.
-
-    Pinned through the real reader rather than a stubbed window, because the wiring is
-    the part that can silently point at the wrong record: the directory here also holds
-    a record from *after* `CYCLE`, and a tool that took the newest record would widen the
-    window to a cycle that has not run yet.
-    """
-    (tmp_path / "cycle-20260916-015906.md").write_text(
-        "---\nid: cyc20260916-015906\n---\n", encoding="utf-8"
-    )
-    (tmp_path / "cycle-20260916-030000.md").write_text(
-        "---\nid: cyc20260916-030000\n---\n", encoding="utf-8"
-    )
-    counter = FakeCounter(verdict_with(push_time=_push(2026, 9, 16, 2, 0, 0)))
-    gh = FakeGh()
-    rc = _run(
-        mod,
-        monkeypatch,
-        counter,
-        gh,
-        [
-            "1255",
-            "--body-file",
-            body_file(f"{CYCLE} — ✅ LGTM"),
-            "--cycles-log",
-            str(tmp_path),
-        ],
-    )
-    err = capsys.readouterr().err
-    assert rc == 2
-    assert gh.calls == []
-    assert f"previous cycle {PREV_CYCLE}" in err, (
-        "the window's source must name the record that was read, so a reader can tell "
-        "which cycle the head was attributed to"
-    )
-    assert "20260916-030000" not in err, "the later record must not widen the window"
-
-
-def test_the_refusal_names_the_window_it_inferred_and_its_blind_spot(
-    mod, monkeypatch, capsys, body_file, tmp_path
-):
-    """Issue #2214, on the side where the cost is a posted vote.
-
-    A window read off the cycle records can reach further back than the clause does when
-    a cycle ran and wrote no record — the resolver then lands on the record before it.
-    `review-queue.py` prints that as a note; here it is a refusal, and the refusal is the
-    one place a cycle cannot answer by re-reading next cycle (nothing was posted, and the
-    head is unchanged), so a reader who is refused on a wider boundary than the clause
-    means has to be told the instant the window used. Measured 2026-10-13: two such
-    cycles in one day, and the boundary landed 2h29m before the cycle that really
-    preceded the measuring one.
-
-    The second half is the control: with `--prev-cycle` the caller named the boundary, so
-    there is no resolution of the tool's to disclose and the sentence is suppressed — a
-    clause appended unconditionally would pass the first half.
-    """
-    (tmp_path / "cycle-20260916-015906.md").write_text(
-        "---\nid: cyc20260916-015906\n---\n", encoding="utf-8"
-    )
-    pushed = _push(2026, 9, 16, 2, 0, 0)
-
-    counter = FakeCounter(verdict_with(push_time=pushed))
-    gh = FakeGh()
-    rc = _run(
-        mod, monkeypatch, counter, gh,
-        ["1255", "--body-file", body_file(f"{CYCLE} — ✅ LGTM"),
-         "--cycles-log", str(tmp_path)],
-    )
-    err = capsys.readouterr().err
-    assert rc == 2 and gh.calls == [], "nothing was posted, and nothing had to be undone"
-    assert "issue #2214" in err, err
-    assert f"previous cycle {PREV_CYCLE}" in err, err
-    assert "2026-09-16T01:59:06" in err, (
-        "the instant the window used is named, not implied - the id alone does not give "
-        "a reader the width"
-    )
-
-    counter = FakeCounter(verdict_with(push_time=pushed))
-    gh = FakeGh()
-    rc = _run(
-        mod, monkeypatch, counter, gh,
-        ["1255", "--body-file", body_file(f"{CYCLE} — ✅ LGTM"),
-         "--prev-cycle", PREV_CYCLE],
-    )
-    err = capsys.readouterr().err
-    assert rc == 2
-    assert "inside the window this cycle treats as its own" in err, err
-    assert "issue #2214" not in err, (
-        "the boundary was named by the caller, so the tool has no record lookup of its "
-        f"own to disclose: {err}"
-    )
 
 
-def test_a_recordless_cycle_moves_the_window_the_poster_refuses_on(
-    mod, monkeypatch, capsys, body_file, tmp_path
-):
-    """Issue #2218 on the side where the cost is a vote that was never posted.
-
-    The queue and the counter resolve the own-window from **both** corpora — the cycle
-    records and the session histories that record every dispatch — because a cycle that
-    died before §4 leaves no record and the records alone then land a whole cycle early
-    (issue #2214). This tool resolved it from the records alone, so a head pushed in that
-    gap was refused a vote it was entitled to post, and a refusal is the one place a
-    cycle cannot answer by re-reading next cycle. Both ends are pinned: the same corpus
-    with the push moved *into* the record-less cycle's own window must still refuse.
-
-    The records hold `PREV_CYCLE` (01:59:06) and the histories name a cycle dispatched at
-    02:00:00 that wrote none, so the cycle immediately before `CYCLE` began at 02:00:00
-    rather than at 01:59:06 — and the push at 01:59:30 below is `PREV_CYCLE`'s work, two
-    cycles back, which the clause lets through.
-    """
-    records = tmp_path / "records"
-    records.mkdir()
-    (records / f"cycle-{PREV_CYCLE[3:]}.md").write_text("x", encoding="utf-8")
-    sessions = tmp_path / "sessions" / "emrg-evolution-emrg-task"
-    sessions.mkdir(parents=True)
-    (sessions / "history_260916.jsonl").write_text(
-        json.dumps({
-            "type": "message",
-            "role": "user",
-            "content": "## Evolution Cycle\n\nyou are cycle cyc20260916-020000 of x",
-            "timestamp": "2026-09-16T02:00:00",
-        }) + "\n",
-        encoding="utf-8",
-    )
-    argv = ["1255", "--body-file", body_file(f"{CYCLE} — ✅ LGTM"),
-            "--cycles-log", str(records)]
 
-    counter = FakeCounter(
-        verdict_with(push_time=_push(2026, 9, 16, 1, 59, 30)),
-        verdict_with([vote()], counted=[True], valid_count=1),
-    )
-    gh = FakeGh()
-    rc = _run(mod, monkeypatch, counter, gh, argv)
-    out = capsys.readouterr()
-    assert rc == 0, out.err
-    assert "inside the window" not in out.err, out.err
-    assert len(gh.calls) == 1 and gh.calls[0][:3] == ["pr", "review", "1255"], (
-        "the vote was posted, which is the whole point of the fix"
-    )
 
-    counter = FakeCounter(verdict_with(push_time=_push(2026, 9, 16, 2, 0, 30)))
-    gh = FakeGh()
-    rc = _run(mod, monkeypatch, counter, gh, argv)
-    err = capsys.readouterr().err
-    assert rc == 2, err
-    assert gh.calls == [], "nothing was posted, so nothing has to be rolled back"
-    assert "inside the window this cycle treats as its own" in err, err
-    assert "cyc20260916-020000" in err, "the reason must name the window it applied"
 
 
-def test_an_unresolvable_previous_cycle_narrows_the_window_and_says_so(
-    mod, monkeypatch, capsys, body_file, tmp_path
-):
-    """A narrowed window is a strictly weaker reading, and it says so.
 
-    With no records at all the clause still catches what it can always decide — a push
-    inside *this* cycle's own window — and the note reports the narrowing **even though
-    the run ends in a refusal**, because that is the outcome a reader most needs to know
-    the reading was weaker than the rule for. A note printed only on the way to a posted
-    vote would be silent exactly when it matters.
-    """
-    counter = FakeCounter(verdict_with(push_time=_push(2026, 9, 16, 2, 5, 0)))
-    gh = FakeGh()
-    rc = _run(
-        mod,
-        monkeypatch,
-        counter,
-        gh,
-        [
-            "1255",
-            "--body-file",
-            body_file(f"{CYCLE} — ✅ LGTM"),
-            "--cycles-log",
-            str(tmp_path),
-        ],
-    )
-    err = capsys.readouterr().err
-    assert rc == 2
-    assert gh.calls == []
-    assert "note:" in err and "could not be widened" in err
-    assert "only pushes at or after" in err
-    assert "this cycle only" in err, "the note names the window it actually applied"
 
 
-def test_an_unresolvable_previous_cycle_cannot_widen_a_vote_into_a_pass(
-    mod, monkeypatch, capsys, body_file, tmp_path
-):
-    """The narrowed window still lets through what it never claimed — the control for
-    the note above, which would otherwise be satisfied by a tool that refused always.
 
-    The push here sits before *this* cycle began, so the reading that was applied has no
-    opinion about it; the vote goes out and the note rides along with it.
-    """
-    counter = FakeCounter(
-        verdict_with(push_time=_push(2026, 9, 16, 1, 0, 0)),
-        verdict_with([vote()], counted=[True], valid_count=1),
-    )
-    gh = FakeGh()
-    rc = _run(
-        mod,
-        monkeypatch,
-        counter,
-        gh,
-        [
-            "1255",
-            "--body-file",
-            body_file(f"{CYCLE} — ✅ LGTM"),
-            "--cycles-log",
-            str(tmp_path),
-        ],
-    )
-    captured = capsys.readouterr()
-    assert rc == 0
-    assert len(gh.calls) == 1
-    assert "counted" in captured.out
-    assert "could not be widened" in captured.err
 
 
 # ── the landing tree the body claims ────────────────────────────────────────
diff --git a/tests/test_check_vote_count.py b/tests/test_check_vote_count.py
index 4349fff2..054cb94d 100644
--- a/tests/test_check_vote_count.py
+++ b/tests/test_check_vote_count.py
@@ -2127,7 +2127,7 @@ def test_a_vote_cast_inside_the_voting_cycles_own_window_does_not_count(
     out = capsys.readouterr().out
     assert rc == 1, out
     assert "SHORT 0/3" in out, out
-    assert "VOID cyc20260911-080000 - cast inside the window" in out, out
+    assert "VOID cyc20260911-080000 - cast inside the run this vote's cycle treats as its own" in out, out
 
     # (b) the same vote from a cycle that started after it: nothing else changed
     outside = FakeGh([_approve("cyc20260911-110000", vote_at)], push_time=pushed)
@@ -2135,7 +2135,7 @@ def test_a_vote_cast_inside_the_voting_cycles_own_window_does_not_count(
     out = capsys.readouterr().out
     assert rc == 0, out
     assert "READY 1/1" in out, out
-    assert "inside the window" not in out, out
+    assert "cast inside the run this vote's cycle treats as its own" not in out, out
 
 
 def test_a_vote_on_a_head_pushed_by_a_later_cycle_counts(mod, monkeypatch, capsys, tmp_path):
@@ -2163,7 +2163,7 @@ def test_a_vote_on_a_head_pushed_by_a_later_cycle_counts(mod, monkeypatch, capsy
     out = capsys.readouterr().out
     assert rc == 0, out
     assert "READY 1/1" in out, out
-    assert "inside the window" not in out, out
+    assert "cast inside the run this vote's cycle treats as its own" not in out, out
 
     # the control: the same vote, the same push, and a corpus that holds no later cycle —
     # so the span has no far bound to stop it, which is the reading #2334 corrects
@@ -2174,7 +2174,7 @@ def test_a_vote_on_a_head_pushed_by_a_later_cycle_counts(mod, monkeypatch, capsy
               ["1", "--min-votes", "1", "--cycles-log", str(empty)])
     out = capsys.readouterr().out
     assert rc == 1, out
-    assert "VOID cyc20260911-080000 - cast inside the window" in out, out
+    assert "VOID cyc20260911-080000 - cast inside the run this vote's cycle treats as its own" in out, out
 
 
 def test_a_vote_on_a_head_another_instance_pushed_inside_the_window_counts(
@@ -2203,7 +2203,7 @@ def test_a_vote_on_a_head_another_instance_pushed_inside_the_window_counts(
     rc = _run(mod, monkeypatch, mine)
     out = capsys.readouterr().out
     assert rc == 1, out
-    assert f"VOID {cycle} - cast inside the window" in out, out
+    assert f"VOID {cycle} - cast inside the run this vote's cycle treats as its own" in out, out
 
     # (b) the peer pushed it: the same instant is not this instance's own work
     theirs = FakeGh([_approve(cycle, vote_at)], push_time=pushed, pusher=OTHER_LOGIN)
@@ -2211,7 +2211,7 @@ def test_a_vote_on_a_head_another_instance_pushed_inside_the_window_counts(
     out = capsys.readouterr().out
     assert rc == 0, out
     assert "READY 1/1" in out, out
-    assert "inside the window" not in out, out
+    assert "cast inside the run this vote's cycle treats as its own" not in out, out
     # …and the line says *which* datum decided, because a reader who cannot see it
     # cannot tell an exemption the identity produced from the clock's ordinary answer,
     # and those two are corrected in opposite directions (the review on #1900 asked for
@@ -2224,7 +2224,7 @@ def test_a_vote_on_a_head_another_instance_pushed_inside_the_window_counts(
     rc = _run(mod, monkeypatch, unknown)
     out = capsys.readouterr().out
     assert rc == 1, out
-    assert f"VOID {cycle} - cast inside the window" in out, out
+    assert f"VOID {cycle} - cast inside the run this vote's cycle treats as its own" in out, out
 
     # (d) **this host's other login** - the hole the review on #1900 measured, on
     # 2026-10-08. A host can push under more than one account: GitHub attributes a push
@@ -2242,7 +2242,7 @@ def test_a_vote_on_a_head_another_instance_pushed_inside_the_window_counts(
     rc = _run(mod, monkeypatch, other_mine)
     out = capsys.readouterr().out
     assert rc == 1, f"arm (d), this host's second login: {out}"
-    assert f"VOID {cycle} - cast inside the window" in out, out
+    assert f"VOID {cycle} - cast inside the run this vote's cycle treats as its own" in out, out
 
     # (e) …and the same login stops being this host's once the remote names someone
     # else, which is the direction the exemption exists for. One input changes between
@@ -2253,7 +2253,7 @@ def test_a_vote_on_a_head_another_instance_pushed_inside_the_window_counts(
     out = capsys.readouterr().out
     assert rc == 0, f"arm (e), a stranger's remote: {out}"
     assert "READY 1/1" in out, out
-    assert "inside the window" not in out, out
+    assert "cast inside the run this vote's cycle treats as its own" not in out, out
 
 
 def test_a_remote_url_names_its_account_in_every_form_it_is_written(mod):
@@ -2397,160 +2397,12 @@ def _ran_a_command(*args, **kwargs):
     assert caught.code == 2
 
 
-def test_the_previous_cycles_window_applies_too(mod, monkeypatch, capsys, tmp_path):
-    """The wider end of the same window: the cycle *before* this one is this cycle.
 
-    A head pushed while the previous cycle ran is that cycle's own, because every cycle
-    on a host is the same instance running again. The narrow reading (this cycle's own
-    start, which is all the test above needs) lets the vote through here, and the rule
-    does not - so the previous cycle's record is written into a directory the test names
-    (`--cycles-log`), where the reading is the fixture's and not the host's corpus.
-    """
-    corpus = tmp_path / "cycles"
-    corpus.mkdir()
-    (corpus / "cycle-20260911-090000.md").write_text("# a cycle record\n", encoding="utf-8")
-    argv = ["1", "--cycles-log", str(corpus)]
-    vote_at = _push(2026, 9, 11, 10, 30)
-
-    # (a) pushed at 09:30: after the previous cycle began, before this one did
-    wide = FakeGh(
-        [_approve("cyc20260911-100000", vote_at)], push_time=_push(2026, 9, 11, 9, 30)
-    )
-    rc = _run(mod, monkeypatch, wide, argv)
-    out = capsys.readouterr().out
-    assert rc == 1, out
-    assert "VOID cyc20260911-100000" in out, out
-    assert "cyc20260911-090000" in out, "the reason must name the window it applied"
-
-    # (b) the same corpus, the push moved before the previous cycle's start
-    narrow = FakeGh(
-        [_approve("cyc20260911-100000", vote_at)], push_time=_push(2026, 9, 11, 8, 30)
-    )
-    rc = _run(mod, monkeypatch, narrow, argv)
-    out = capsys.readouterr().out
-    assert "1/3 valid votes" in out, out
-    assert "inside the window" not in out, out
-
-
-def test_an_unreadable_corpus_does_not_credit_the_vote_the_readable_one_voids(
-    mod, monkeypatch, capsys, tmp_path
-):
-    """Issue #2275: two answers that render alike must not answer alike.
-
-    "no cycle record before this cycle in <dir>" is a **measurement** — the corpus was
-    listed and holds nothing earlier — and the narrower window that follows is the intended
-    reading (`_pinned_cycle_records` is that same state). A corpus that could not be listed
-    answers nothing, and the window falls back to the narrow one all the same; the vote below
-    is then *credited* where the readable corpus voids it. Measured 2026-10-15 on #2271 with
-    `EMRG_CYCLES_LOG=/nonexistent`: `2/3` with the vote `OK - counts`, against `1/3` and
-    `VOID` from the real corpus.
-
-    Both arms are the same vote, head and pusher, and differ only in whether the corpus can
-    be listed — so a counter that refused every window fails the second assertion and one
-    that never measured fails the third.
-    """
-    corpus = tmp_path / "cycles"
-    corpus.mkdir()
-    (corpus / "cycle-20260911-090000.md").write_text("# a cycle record\n", encoding="utf-8")
-    vote_at = _push(2026, 9, 11, 10, 30)
-    # Inside the previous cycle's start (09:00), before the voting cycle's (10:00) — the
-    # one shape where the wide and narrow windows disagree.
-    pushed = _push(2026, 9, 11, 9, 30)
-    gh = FakeGh([_approve("cyc20260911-100000", vote_at)], push_time=pushed)
-
-    # (a) the corpus that can be listed: the clause voids the vote
-    rc = _run(mod, monkeypatch, gh, ["1", "--cycles-log", str(corpus)])
-    out = capsys.readouterr().out
-    assert rc == 1, out
-    assert "SHORT 0/3" in out, out
-    assert "VOID cyc20260911-100000" in out, out
-    assert "cyc20260911-090000" in out, "the reason must name the window it applied"
-
-    # (b) the same vote, the same head, a corpus that cannot be listed at all: no boundary
-    #     was measured, so the narrow one may not stand in for it
-    rc = _run(mod, monkeypatch, gh, ["1", "--cycles-log", str(tmp_path / "gone")])
-    out = capsys.readouterr().out
-    assert rc == 1, out
-    assert "SHORT 0/3" in out, out
-    assert "OK   cyc20260911-100000" not in out, (
-        f"a vote was credited on a window nobody measured: {out}"
-    )
-    assert "could not be read" in out and "2275" in out, out
-
-
-def test_the_counter_reads_the_window_the_queue_reads(mod, monkeypatch, capsys, tmp_path):
-    """Issue #2218 at the counter: the same clause, resolved from **both** corpora.
 
-    `<repo>/.emrg/memory` holds a record for the cycle two back; the session histories
-    beside it record every *dispatch*. A cycle was dispatched between them and wrote no
-    record — it died before §4 — so the cycle immediately before this one is the
-    record-less one, and a head it did **not** push is votable. Read from the records
-    alone the boundary lands a whole cycle earlier and the vote below is voided; the
-    queue, which resolves from both corpora, calls the same head votable (issue #2218:
-    the records-only boundary is too early for 20 of the corpus's 350 records).
-
-    That difference is a count a cycle acts on before merging, so both ends are pinned
-    here: the same corpus with the push moved *into* the record-less cycle's own window
-    must still void it — a counter that stopped applying the clause would pass the first
-    half alone.
-    """
-    records = tmp_path / "records"
-    records.mkdir()
-    (records / "cycle-20260911-090000.md").write_text("# a cycle record\n", encoding="utf-8")
-    sessions = tmp_path / "sessions" / "emrg-evolution-emrg-task"
-    sessions.mkdir(parents=True)
-    (sessions / "history_260911.jsonl").write_text(
-        json.dumps({
-            "type": "message",
-            "role": "user",
-            "content": "## Evolution Cycle\n\nyou are cycle cyc20260911-093000 of x",
-            "timestamp": "2026-09-11T09:30:00",
-        }) + "\n",
-        encoding="utf-8",
-    )
-    vote = _approve("cyc20260911-100000", _push(2026, 9, 11, 10, 30))
-    argv = ["1", "--cycles-log", str(records)]
 
-    # (a) pushed at 09:15: after the record's cycle began, before the record-less one did
-    counted = FakeGh([vote], push_time=_push(2026, 9, 11, 9, 15))
-    _run(mod, monkeypatch, counted, argv)
-    out = capsys.readouterr().out
-    assert "1/3 valid votes" in out, out
-    assert "VOID" not in out, out
-    assert "inside the window" not in out, out
-
-    # (b) the control: 09:45 is the record-less cycle's own work, which *is* the cycle
-    # immediately before this one - the case the clause exists to protect.
-    inside = FakeGh([vote], push_time=_push(2026, 9, 11, 9, 45))
-    rc = _run(mod, monkeypatch, inside, argv)
-    out = capsys.readouterr().out
-    assert rc == 1, out
-    assert "VOID cyc20260911-100000" in out, out
-    assert "cyc20260911-093000" in out, "the reason must name the window it applied"
 
 
-def test_the_void_reason_names_the_window_it_inferred_and_its_blind_spot(mod, tmp_path):
-    """Issue #2214 at the counter: same clause, same reader, one more carrier.
 
-    This counter has no `--prev-cycle`, so every window it draws is *inferred* from the
-    records - the state the note describes is not an option here but the only case. It
-    matters because the output is a count a cycle acts on: a window too wide voids a vote
-    that stands and reports `0/3` where the clause's own boundary reports `1/3`, and the
-    merge decision follows the count. The instant is named so the width is inspectable
-    rather than taken on trust.
-    """
-    corpus = tmp_path / "corpus"
-    corpus.mkdir()
-    (corpus / "cycle-20260911-090000.md").write_text("x", encoding="utf-8")
-    counted, why = mod.own_head_window(
-        "cyc20260911-100000",
-        push_time=_push(2026, 9, 11, 9, 30),
-        push_time_exact=True,
-        cycles_log=str(corpus),
-    )
-    assert counted is True, why
-    assert "at or after 2026-09-11T09:00:00" in why, why
-    assert "issue #2214" in why, why
 
 
 def test_the_void_reason_does_not_claim_another_tools_refusal(mod, tmp_path):
@@ -2570,15 +2422,18 @@ def test_the_void_reason_does_not_claim_another_tools_refusal(mod, tmp_path):
     """
     corpus = tmp_path / "corpus"
     corpus.mkdir()
-    (corpus / "cycle-20260911-090000.md").write_text("x", encoding="utf-8")
+    # The record of the cycle that *follows* the voting one, so the span has a far end
+    # and the push below falls inside it: the clause's own text is what this arm is about,
+    # and a push outside the window would leave it unvoiced.
+    (corpus / "cycle-20260911-110000.md").write_text("x", encoding="utf-8")
     log = str(corpus)
-    inside = _push(2026, 9, 11, 9, 30)  # inside the window the cycle above opens
+    inside = _push(2026, 9, 11, 10, 30)  # inside the voting cycle's own run
 
     counted, why = mod.own_head_window(
         "cyc20260911-100000", push_time=inside, push_time_exact=True, cycles_log=log
     )
     assert counted is True, why
-    assert "cast inside the window" in why, why  # the clause is still named
+    assert "cast inside the run this vote's cycle treats as its own" in why, why  # the clause is still named
     assert "counts for nobody" in why, why  # …with this tool's verdict
     assert "refuses to post" not in why, why  # …and not another tool's action
 
@@ -2602,6 +2457,9 @@ def test_a_vote_by_another_instance_is_not_voided_by_this_hosts_window(
         was pushed …, at or after 2026-10-05T08:07:17+08:00 (previous cycle
         cyc20261005-080717)
 
+    (the wording then; the clause's own text now reads `cast inside the run this vote's
+    cycle treats as its own`, and the near bound is the voting cycle's own start)
+
     and `gh api repos/argszero/emrg/pulls/1851/reviews` attributes both to `pm25coder`,
     whose cycle measures its host as Windows - the cycles of another instance, on a
     host whose records are not the ones this counter reads. The window is drawn from
@@ -2622,7 +2480,7 @@ def test_a_vote_by_another_instance_is_not_voided_by_this_hosts_window(
     rc = _run(mod, monkeypatch, mine)
     out = capsys.readouterr().out
     assert rc == 1, out
-    assert f"VOID {cycle} - cast inside the window" in out, out
+    assert f"VOID {cycle} - cast inside the run this vote's cycle treats as its own" in out, out
 
     theirs = FakeGh(
         [_approve(cycle, vote_at, author=OTHER_LOGIN)], push_time=pushed
@@ -2631,7 +2489,7 @@ def test_a_vote_by_another_instance_is_not_voided_by_this_hosts_window(
     out = capsys.readouterr().out
     assert rc == 0, out
     assert "READY 1/1" in out, out
-    assert "inside the window" not in out, (
+    assert "cast inside the run this vote's cycle treats as its own" not in out, (
         "a vote by another instance is not this host's self-review, so the clause its "
         "window carries is not asked of it"
     )
@@ -2725,7 +2583,7 @@ def test_a_head_with_no_ci_run_leaves_the_clause_unapplied(mod, monkeypatch, cap
     out = capsys.readouterr().out
     assert rc == 1, out
     assert "BLOCKED 3/3 valid votes" in out, out
-    assert "inside the window" not in out, out
+    assert "cast inside the run this vote's cycle treats as its own" not in out, out
 
 
 def test_the_pusher_is_the_actor_of_the_run_whose_time_was_read(mod, monkeypatch):
@@ -2756,13 +2614,16 @@ def test_the_counter_voids_exactly_the_votes_cast_vote_refuses_to_post(mod, monk
     Sharing the machinery is not the claim; sharing the *verdict* is. If a later change
     reaches one tool and not the other, the hole re-opens on whichever side was left
     behind - a vote nobody may post, or a vote counted that its own poster refused. So
-    the same (cycle, head) pairs are put to both, and both ends of the boundary are
-    covered: before the window, the previous cycle's end, this cycle's own end, and a
-    cycle further back.
+    the same (cycle, head) pairs are put to both, and **both** ends of the window are
+    covered: at this cycle's own start, inside its run, at the following cycle's start,
+    one second before it began, and two cycles back.
     """
     corpus = tmp_path / "cycles"
     corpus.mkdir()
-    (corpus / "cycle-20260911-090000.md").write_text("# a cycle record\n", encoding="utf-8")
+    # The record of the cycle that follows the voting one: it is what closes the span at
+    # the far end, so the "at or after the far end" arm below is a reading rather than an
+    # open window's accident.
+    (corpus / "cycle-20260911-110000.md").write_text("# a cycle record\n", encoding="utf-8")
     log = str(corpus)
     counter, cast_vote = mod, _cast_vote()
     # The identity half is asked through `gh api user`, and neither end is driven through
@@ -2775,12 +2636,12 @@ def test_the_counter_voids_exactly_the_votes_cast_vote_refuses_to_post(mod, monk
         monkeypatch.setattr(owner, "_own_logins", frozenset({SELF_LOGIN}))
 
     cases = (
-        # (push instant, inside the window?)
-        (_push(2026, 9, 11, 9, 0), True),     # exactly the previous cycle's start
-        (_push(2026, 9, 11, 9, 30), True),    # the previous cycle's window
-        (_push(2026, 9, 11, 10, 30), True),   # this cycle's own window
-        (_push(2026, 9, 11, 8, 30), False),   # before both ends of the window
-        (_push(2026, 9, 11, 7, 30), False),   # before the cycle that precedes it
+        # (push instant, inside the window of `cyc20260911-100000`?)
+        (_push(2026, 9, 11, 10, 0), True),    # exactly this cycle's own start
+        (_push(2026, 9, 11, 10, 30), True),   # inside this cycle's own run
+        (_push(2026, 9, 11, 11, 0), False),   # at the following cycle's start — its work
+        (_push(2026, 9, 11, 9, 59), False),   # one second before this cycle began
+        (_push(2026, 9, 11, 7, 30), False),   # two cycles back, another actor's work
     )
     for pushed, inside in cases:
         refused, _ = cast_vote.own_head_window(
diff --git a/tests/test_printed_commands_carry_the_python_runner.py b/tests/test_printed_commands_carry_the_python_runner.py
index 1f98e40b..7f4bb35b 100644
--- a/tests/test_printed_commands_carry_the_python_runner.py
+++ b/tests/test_printed_commands_carry_the_python_runner.py
@@ -73,13 +73,21 @@
 what keeps the clause off prose: "update `VERSION_SOURCES` in `scripts/bump-version.py`"
 ends at the file name and is not a thing to run, while `scripts/check-vote-count.py <PR>` is.
 
-What the clause reads on this tree, measured 2026-10-15: **41** command-shaped mentions, in
+What the clause reads on this tree, measured 2026-10-17: **40** command-shaped mentions, in
 nine tools - `bump-version.py` 2, `cast-vote.py` 8, `check-merge-freshness.py` 8,
 `check-merge-sequence.py` 1, `check-release-published.py` 1, `check-stacked-prs.py` 1,
-`check-vote-count.py` 1, `review-queue.py` 18, `run-mutation-arm.py` 1. The newest arrived the
-way the three before it did - through a *remedy*: `review-queue.py`'s row for a head pushed
-below a window whose boundary the record corpus could not measure, whose cure is the counter's
-own report (cycle `cyc20261015-030526`). Before that the newest was
+`check-vote-count.py` 1, `review-queue.py` 17, `run-mutation-arm.py` 1. This is the first
+reading on which the number went **down**, by exactly one, and it went down the same way the
+sentences above went up: a *printed remedy* is a printed command either way.
+`review-queue.py` carried a second `abstain` branch - a head pushed below a window whose
+lower bound the record corpus could not measure, whose printed remedy named
+`scripts/check-vote-count.py <pr>` and offered `--prev-cycle <id>` as the caller's way to
+supply the boundary - and both the branch and the flag went with the widened lower bound
+(cycle `cyc20261017-062633`, on the host's ruling that only a head the voting cycle itself
+pushed is abstained on), so `review-queue.py` reads **17** where it read **18**. A count that
+only ever rises would be a count nobody deletes from. That same row had itself been the
+newest arrival before it, added the way the three before that did - through a *remedy*: its
+cure was the counter's own report (cycle `cyc20261015-030526`). Before that the newest was
 `check-vote-count.py`'s cure for a head with no CI run, which names the re-trigger in
 `check-merge-freshness.py`'s own spelling
 (`bash scripts/re-trigger-ci.sh <branch>`), added the same day as the per-cause cures above it
diff --git a/tests/test_review_queue.py b/tests/test_review_queue.py
index b8d92f45..6207ceb3 100644
--- a/tests/test_review_queue.py
+++ b/tests/test_review_queue.py
@@ -53,11 +53,23 @@
 MASTER = "c" * 40
 PUSH_TIME = "2026-09-17T10:00:00Z"
 CYCLE = "cyc20260917-221117"
-#: The cycle immediately before `CYCLE`: it started at 21:59:29 in the host's own
-#: zone, 11m48s before `CYCLE`. A cycle id *is* its local start time, so this pair is
-#: what the abstention window's two ends are pinned against.
+#: A cycle id that started 11m48s before `CYCLE`, in the host's own zone. A cycle id *is*
+#: its local start time, and since 2026-10-16 the window's near bound is each cycle's own
+#: start: a push strictly before 22:11:17 belongs to whoever made it — the previous cycle
+#: included — so `CYCLE` may vote there, while a push from 22:11:17 on is its own work and
+#: it must abstain. It is also the filler record in the corpora below, whose only job is
+#: to be an *earlier* record than `CYCLE`.
 PREV_CYCLE = "cyc20260917-215929"
 
+#: A record corpus with **nothing** in it, for runs that must not read the host's own
+#: `cycle-*.md` files. The window's *far* bound is the cycle that follows this one, and on
+#: this host every synthetic id in this file (2026-09-17) has a real successor minutes
+#: later, so a run left to the default corpus would close the span at a machine-dependent
+#: instant. A path that does not exist answers "no cycle record after this cycle", which
+#: leaves the span open above — the state the posting cycle itself is in. Callers that
+#: exercise the corpus pass their own `--cycles-log`.
+NO_RECORDS = REPO_ROOT / "tests" / "_no_such_cycles_log"
+
 #: The login this instance votes under, and one it does not. The abstention clause asks
 #: whose push a head was before it asks about the window, so both ends of that
 #: comparison need a name (the same pair `tests/test_check_vote_count.py` uses).
@@ -344,19 +356,16 @@ def _read(mod, monkeypatch, votes, fresh, *, number=1, cycle=None, prs=()):
     argv = [str(pr) for pr in prs] if prs else [str(number)]
     if cycle:
         argv += ["--cycle", cycle]
-        # Pin the previous cycle, so the abstention window is a property of this file
-        # and not of the machine that runs it. Left to itself the tool resolves it from
-        # the host's own cycles log, and the window's start is then whatever record
-        # happens to sort last before this cycle's id: on a corpus that reaches back to
-        # 2026-09-17 that is `PREV_CYCLE` (21:59) and every `PUSH_TIME` row is outside
-        # the window, but a record set with a gap there falls back to `cycle-20260916`
-        # and moves the start *behind* `PUSH_TIME`, which turns each `vote` /
-        # `already-voted` row under test into `abstain`. Measured 2026-09-28: six rows
-        # failed on a host whose newest record before `CYCLE` is 2026-09-16T15:46:18,
-        # while a checkout with no records at all (which is what CI has) passes them.
-        # Callers that exercise the log-reading path pass their own `--cycles-log`.
-        if "--cycles-log" not in argv and "--prev-cycle" not in argv:
-            argv += ["--prev-cycle", PREV_CYCLE]
+        # Pin the record corpus, so the window's *far* bound is a property of this file
+        # and not of the machine that runs it: `following_cycle` reads the cycle that
+        # follows from `--cycles-log`, and this host's own records give every synthetic id
+        # here (2026-09-17) a successor minutes later — which would close the span before
+        # the pushes these rows are about. A corpus with no records answers "nothing
+        # follows this cycle", leaving the span open above, which is the state the posting
+        # cycle itself is in. Callers that exercise the corpus pass their own
+        # `--cycles-log`.
+        if "--cycles-log" not in argv:
+            argv += ["--cycles-log", str(NO_RECORDS)]
     return mod.main(argv)
 
 
@@ -740,7 +749,7 @@ def test_an_unstable_head_whose_checks_passed_is_votable_not_blocked(mod, monkey
             run_id="37372464666", started_at="2026-10-05T20:52:57Z", id=2,
         ),
     )
-    rc = mod.main(["1", "--prev-cycle", PREV_CYCLE])
+    rc = mod.main(["1", "--cycles-log", str(NO_RECORDS)])
     out = capsys.readouterr().out
     assert rc == 0
     assert "unblock" not in out, "a head whose checks passed is not a branch defect"
@@ -769,7 +778,7 @@ def test_an_unstable_head_whose_newest_check_never_concluded_is_an_unblock(
             run_id="37390520380", started_at="2026-10-05T23:56:31Z", id=2,
         ),
     )
-    rc = mod.main(["1", "--prev-cycle", PREV_CYCLE])
+    rc = mod.main(["1", "--cycles-log", str(NO_RECORDS)])
     out = capsys.readouterr().out
     assert rc == 0
     assert "unblock" in out
@@ -785,7 +794,7 @@ def test_an_unread_check_run_list_keeps_the_state_blocking(mod, monkeypatch, cap
     """
     votes = FakeVotes(reviews=[], mergeable="MERGEABLE", state="UNSTABLE")
     _install(mod, monkeypatch, votes, FakeFresh())
-    rc = mod.main(["1", "--prev-cycle", PREV_CYCLE])
+    rc = mod.main(["1", "--cycles-log", str(NO_RECORDS)])
     out = capsys.readouterr().out
     assert rc == 0
     assert "unblock" in out
@@ -816,7 +825,7 @@ def check_pr(self, number):
     fresh = FakeFresh()
     _install(mod, monkeypatch, votes, fresh)
     monkeypatch.setattr(mod, "freshness", lambda: Boom())
-    rc = mod.main(["1", "--prev-cycle", PREV_CYCLE])
+    rc = mod.main(["1", "--cycles-log", str(NO_RECORDS)])
     out = capsys.readouterr().out
     assert rc == 2, "a PR whose CI half could not be read is a failure to measure"
     assert "unmeasurable: #1" in out, "the footer must name it, not only the exit code"
@@ -829,7 +838,7 @@ def check_pr(self, number):
 
     # control: the identical reading, with the CI half readable, is the branch-state row
     monkeypatch.setattr(mod, "freshness", lambda: fresh)
-    assert mod.main(["1", "--prev-cycle", PREV_CYCLE]) == 0
+    assert mod.main(["1", "--cycles-log", str(NO_RECORDS)]) == 0
     control = capsys.readouterr().out
     assert "unblock" in control
     assert "unmeasurable" not in control
@@ -1066,10 +1075,10 @@ def test_json_carries_the_reading_and_the_action(mod, monkeypatch, capsys):
     # test of the environment. `test_the_json_document_keeps_its_shape_and_carries_the_
     # same_fact` pins the live reading.
     monkeypatch.setattr(mod, "local_tree", lambda: ("/checkout", "some-branch", "b" * 40))
-    # `--prev-cycle` rather than the default cycle-record directory: the shape has to
-    # be the same everywhere, and the inferred window is a fact about the host.
+    # An empty record corpus rather than the default one: the shape has to be the same
+    # everywhere, and which cycle follows this one is a fact about the host.
     rc = mod.main(
-        ["1", "--cycle", CYCLE, "--prev-cycle", PREV_CYCLE, "--json"]
+        ["1", "--cycle", CYCLE, "--cycles-log", str(NO_RECORDS), "--json"]
     )
     payload = json.loads(capsys.readouterr().out)
     assert rc == 0
@@ -1096,9 +1105,12 @@ def test_json_carries_the_reading_and_the_action(mod, monkeypatch, capsys):
         "head_pushed_at": PUSH_TIME,
         "head_pushed_exact": True,
         "vote_window_start": (
-            datetime(2026, 9, 17, 21, 59, 29, tzinfo=LOCAL).isoformat(timespec="seconds")
+            datetime(2026, 9, 17, 22, 11, 17, tzinfo=LOCAL).isoformat(timespec="seconds")
+        ),
+        "vote_window_source": (
+            "this cycle's own run (started "
+            f"{datetime(2026, 9, 17, 22, 11, 17, tzinfo=LOCAL).isoformat(timespec='seconds')})"
         ),
-        "vote_window_source": f"previous cycle {PREV_CYCLE} (named by --prev-cycle)",
         "stale": True,
         "stale_kind": "ancestry",
         "behind_by": 1,
@@ -1123,12 +1135,12 @@ def test_the_summary_counts_every_row_once(mod, monkeypatch, capsys):
 # --- the abstention clause: whose head is it? (issue #1408) ------------------
 #
 # The counter's half of "may this cycle vote here" is the count. The other half is
-# *whose head is it*, and that is the half that has cost votes: a cycle neither votes
-# on nor merges a head it pushed, and because every cycle on a host is the same
-# instance running again, the window immediately before this one counts as its own
-# (the applied precedent is `cyc20260917-125823`). `CYCLE` began at 22:11:17 in the
-# host's zone and `PREV_CYCLE` at 21:59:29, so the two ends of the window are 11m48s
-# apart and every push below is named in that zone rather than in UTC.
+# *whose head is it*, and that is the half that has cost votes: a cycle neither votes on
+# nor merges a head **it pushed**. The window is that cycle's own run — from `CYCLE`'s
+# start (22:11:17 in the host's zone) to the start of the cycle that follows it — and a
+# head pushed before it began belongs to whoever pushed it: the host ruled the older
+# "the previous cycle's window counts as one's own" reading away on 2026-10-16T22:18:15.
+# Every push below is named in the host's zone rather than in UTC.
 
 
 def _run(mod, monkeypatch, votes, fresh, argv):
@@ -1161,17 +1173,24 @@ def test_a_head_pushed_inside_this_cycle_is_an_abstain(mod, monkeypatch, capsys)
     assert "check-vote-count.py 1" in out
 
 
-def test_a_head_pushed_by_the_previous_cycle_is_an_abstain(mod, monkeypatch, capsys):
-    """The half the precedent widened: 22:05 is after the previous cycle began
-    (21:59:29) and before this one did, so the push belongs to the cycle immediately
-    before — the same instance, one window back."""
+def test_a_head_pushed_by_the_previous_cycle_is_votable(mod, monkeypatch, capsys):
+    """The reading the host ruled for on 2026-10-16T22:18:15.
+
+    22:05 is after the previous cycle began (21:59:29) and before this one did, so a
+    wider window would call it this instance's own work. The host ruled that away —
+    "I think the requirement 'nor one pushed by the cycle immediately before it' should
+    not exist. That the cycle that pushed it cannot vote is already enough" (translated
+    from the Chinese original) — so the row is `vote`, and the vote is one this cycle
+    may spend.
+    """
     votes = FakeVotes(reviews=[], push=_push(2026, 9, 17, 22, 5))
     fresh = FakeFresh()
-    _run(mod, monkeypatch, votes, fresh,
-         ["1", "--cycle", CYCLE, "--prev-cycle", PREV_CYCLE])
+    _run(mod, monkeypatch, votes, fresh, ["1", "--cycle", CYCLE])
     out = capsys.readouterr().out
-    assert "abstain" in out
-    assert PREV_CYCLE in out
+    assert "abstain" not in _rows(out), out
+    row = _rows(out).splitlines()[0]
+    assert "vote" in row or "measure-then-vote" in row, row
+    assert "cast-vote.py 1" in out, "the vote this cycle may spend is the row's remedy"
 
 
 def test_the_window_ends_where_the_following_cycle_begins(mod, tmp_path):
@@ -1187,9 +1206,11 @@ def test_the_window_ends_where_the_following_cycle_begins(mod, tmp_path):
     (records / f"cycle-{PREV_CYCLE[3:]}.md").write_text("x", encoding="utf-8")
     (records / "cycle-20260917-223000.md").write_text("x", encoding="utf-8")
 
-    window = mod.own_window(CYCLE, None, str(records), None)
+    window = mod.own_window(CYCLE, str(records))
 
-    assert window.start == mod.cycle_start(PREV_CYCLE), "the start is unchanged by #2334"
+    assert window.start == mod.cycle_start(CYCLE), (
+        "the near bound is this cycle's own start — the corpus decides only the far one"
+    )
     assert window.end == mod.cycle_start("cyc20260917-223000"), (
         "the far bound is the instant the cycle after this one began"
     )
@@ -1217,7 +1238,7 @@ def test_a_window_with_no_later_cycle_is_open_at_its_far_end(mod, tmp_path):
     records.mkdir()
     (records / f"cycle-{PREV_CYCLE[3:]}.md").write_text("x", encoding="utf-8")
 
-    window = mod.own_window(CYCLE, None, str(records), None)
+    window = mod.own_window(CYCLE, str(records))
 
     assert window.end is None
     assert window.window_end_text() == ""
@@ -1244,7 +1265,7 @@ def test_a_head_pushed_by_a_later_cycle_is_not_an_abstain_row(mod, monkeypatch,
     out = capsys.readouterr().out
     assert rc == 0
     assert f"cast-vote.py 1 --cycle {CYCLE}" in out, out
-    assert "inside the window this cycle treats as its own" not in out, out
+    assert "inside the run this cycle treats as its own" not in out, out
 
 
 def test_a_head_pushed_past_a_corpus_with_no_later_cycle_reads_abstain(mod, monkeypatch,
@@ -1264,7 +1285,7 @@ def test_a_head_pushed_past_a_corpus_with_no_later_cycle_reads_abstain(mod, monk
     _run(mod, monkeypatch, FakeVotes(reviews=[], push=pushed), FakeFresh(),
          ["1", "--cycle", CYCLE, "--cycles-log", str(only_prev)])
     out = capsys.readouterr().out
-    assert "inside the window this cycle treats as its own" in out, out
+    assert "inside the run this cycle treats as its own" in out, out
 
 
 def test_a_head_another_instance_pushed_is_not_this_cycles_own(mod, monkeypatch, capsys):
@@ -1350,79 +1371,12 @@ def test_a_head_with_no_actor_reading_keeps_the_abstain(mod, monkeypatch, capsys
     assert "abstain" in out
 
 
-def test_a_push_at_the_previous_cycles_start_is_inside_the_window(mod, monkeypatch, capsys):
-    """The boundary is closed at the start: a window runs from its own id to the next
-    one, so the previous cycle's first instant belongs to it and not to the cycle
-    before it."""
-    votes = FakeVotes(reviews=[], push=_push(2026, 9, 17, 21, 59, 29))
-    fresh = FakeFresh()
-    _run(mod, monkeypatch, votes, fresh,
-         ["1", "--cycle", CYCLE, "--prev-cycle", PREV_CYCLE])
-    out = capsys.readouterr().out
-    assert "abstain" in out
 
 
-def test_a_head_pushed_two_cycles_back_is_still_votable(mod, monkeypatch, capsys):
-    """The negative control for the clause: the window is one cycle wide and no
-    wider. 20:00 is before the previous cycle began, so nothing about it is one's own
-    and the row is the ordinary vote it would always have been."""
-    votes = FakeVotes(reviews=[], push=_push(2026, 9, 17, 20, 0))
-    fresh = FakeFresh()
-    _run(mod, monkeypatch, votes, fresh,
-         ["1", "--cycle", CYCLE, "--prev-cycle", PREV_CYCLE])
-    out = capsys.readouterr().out
-    assert "abstain" not in _rows(out)
-    assert "cast-vote.py 1 --cycle cyc20260917-221117" in out
 
 
-def test_a_push_below_a_window_whose_far_end_was_never_measured_is_not_a_vote(
-    mod, monkeypatch, capsys, tmp_path
-):
-    """Issue #2275 at the row, and the arm the CI leg found: a narrowed window decides only
-    the half below its start.
-
-    22:05 is after the previous cycle began (21:59:29) and before this one did (22:11:17),
-    so the *widened* window is what decides it — and where the records could not be listed
-    that end was never measured. The row said `vote` there, inviting a vote the poster
-    refuses and the counter voids; it says `abstain` now, naming the corpus to pass.
-
-    Its control is the sibling test below, and the pair is split because the fakes are
-    installed per test: a second `_run` in one test re-installs them onto the first fake,
-    which reads as an unreadable count rather than as the row under test (measured while
-    writing this — the `read-first` row it produced is the trap, not the finding).
-    """
-    votes = FakeVotes(reviews=[], push=_push(2026, 9, 17, 22, 5))
-    _run(
-        mod, monkeypatch, votes, FakeFresh(),
-        ["1", "--cycle", CYCLE, "--cycles-log", str(tmp_path / "gone")],
-    )
-    out = capsys.readouterr().out
-    row = next(line for line in out.splitlines() if line.startswith("#1 "))
-    assert "abstain" in row, f"a boundary nobody measured is not passed: {row}"
-    assert "cast-vote.py" not in row, "never the command that spends the vote"
-    assert "--cycles-log" in out, "the remedy is the corpus this window needs, named"
-    assert "never measured" in out, "and the reason says which end was missing"
 
 
-def test_a_push_below_a_measured_narrow_window_is_still_a_vote(
-    mod, monkeypatch, capsys, tmp_path
-):
-    """The control for the row above, and the case the whole narrowing rests on: a corpus
-    that **was** listed and holds no earlier record has measured the boundary — it answered
-    "nothing earlier" — so a push below this cycle's own start is the ordinary votable head
-    it has always been. Without this arm a tool that abstained on every window it could not
-    widen would pass, and the narrowed window would stop being a reading at all."""
-    listed = tmp_path / "listed-and-empty"
-    listed.mkdir()
-    votes = FakeVotes(reviews=[], push=_push(2026, 9, 17, 22, 5))
-    _run(
-        mod, monkeypatch, votes, FakeFresh(),
-        ["1", "--cycle", CYCLE, "--cycles-log", str(listed)],
-    )
-    out = capsys.readouterr().out
-    row = next(line for line in out.splitlines() if line.startswith("#1 "))
-    assert "vote" in row and "abstain" not in row, row
-    assert "cast-vote.py 1 --cycle cyc20260917-221117" in out
 
 
 def test_a_head_this_cycle_pushed_is_not_merged_either(mod, monkeypatch, capsys):
@@ -1452,54 +1406,33 @@ def test_an_inexact_push_time_never_decides_the_window(mod, monkeypatch, capsys)
     assert "abstain" not in _rows(out)
 
 
-def test_the_previous_cycle_is_read_from_the_cycle_records(mod, monkeypatch, capsys,
-                                                           tmp_path):
-    """`--cycles-log`: the newest cycle record that sorts before this cycle's id — not
-    the newest record, and not an archive's filename.
 
-    The records are named `cycle-<date>-<time>.md`, without the id's `cyc` prefix, so
-    this also pins the filename-to-id mapping: the row names `PREV_CYCLE` with its
-    `cyc`, which is not what the filename says.
-    """
-    (tmp_path / f"cycle-{PREV_CYCLE[3:]}.md").write_text("x", encoding="utf-8")
-    (tmp_path / "cycle-20260917-100000.md").write_text("x", encoding="utf-8")
-    (tmp_path / f"cycle-{CYCLE[3:]}.md").write_text("x", encoding="utf-8")
-    (tmp_path / "cycle-archive-20260917.md").write_text("x", encoding="utf-8")
-    votes = FakeVotes(reviews=[], push=_push(2026, 9, 17, 22, 5))
-    fresh = FakeFresh()
-    _run(mod, monkeypatch, votes, fresh,
-         ["1", "--cycle", CYCLE, "--cycles-log", str(tmp_path)])
-    out = capsys.readouterr().out
-    assert "abstain" in out
-    assert PREV_CYCLE in out
 
+def test_the_far_bound_is_read_across_two_roots(mod, tmp_path):
+    """The earliest record *after* this cycle wins across the roots, not within one.
 
-def test_a_corpus_split_across_two_roots_is_read_whole(mod, tmp_path):
-    """The newest record wins *across* the roots, not within one of them.
-
-    The state this search exists for (measured 2026-09-25): 1,354 records sit beside
-    the checkout, while the root this tree's template names — the checkout one D9
-    (PR #1555) re-based onto — is empty, so a reinstall moves the next records onto
-    the other side. Either root alone then answers a different question: the older one
-    freezes the window at the last cycle before the move, the newer one cannot resolve
-    it at all until records accumulate there. The control is the first assertion — the
-    older root read alone really does answer the older cycle. Order is not the claim:
-    the same answer has to come out either way round.
+    The corpus is split for the reason records accumulate (measured 2026-09-25): the
+    records sit beside the checkout while the root a reinstall moves the next ones onto
+    starts empty, so either root read alone answers a different question — the older one
+    freezes the span at whatever it happens to hold. The control is the first assertion:
+    the older root alone holds nothing after `CYCLE`, so the span is open there and the
+    same head would read `abstain`. Order is not the claim — the same answer has to come
+    out either way round.
     """
     legacy, project = tmp_path / "legacy", tmp_path / "project"
     legacy.mkdir()
     project.mkdir()
     (legacy / "cycle-20260917-100000.md").write_text("x", encoding="utf-8")
-    (project / f"cycle-{PREV_CYCLE[3:]}.md").write_text("x", encoding="utf-8")
+    (project / "cycle-20260917-223000.md").write_text("x", encoding="utf-8")
 
-    frozen, _, frozen_gap = mod.previous_cycle(CYCLE, (legacy,))
-    assert frozen == "cyc20260917-100000", "the older root alone is the frozen reading"
+    frozen, _, frozen_gap = mod.following_cycle(CYCLE, (legacy,))
+    assert frozen == "", "the older root alone holds no record after this cycle"
     assert frozen_gap == "", "the root was listed, so nothing fell short"
 
     for order in ((project, legacy), (legacy, project)):
-        previous, where, gap = mod.previous_cycle(CYCLE, order)
-        assert previous == PREV_CYCLE, (
-            f"the newest record wins across the roots, in either order ({order})"
+        following, where, gap = mod.following_cycle(CYCLE, order)
+        assert following == "cyc20260917-223000", (
+            f"the earliest later record wins across the roots, in either order ({order})"
         )
         assert where == str(project), "the answer names the root it came from"
         assert gap == "", "both roots were listed"
@@ -1508,25 +1441,25 @@ def test_a_corpus_split_across_two_roots_is_read_whole(mod, tmp_path):
 def test_a_root_that_cannot_be_read_is_named_rather_than_passed_over(mod, tmp_path):
     """An answer drawn from the readable half is still an answer — and the reader is
     told which half it came from, because a record in the unreadable one could be
-    newer."""
+    *later*, which is the direction that closes the span."""
     project = tmp_path / "project"
     project.mkdir()
-    (project / f"cycle-{PREV_CYCLE[3:]}.md").write_text("x", encoding="utf-8")
+    (project / "cycle-20260917-223000.md").write_text("x", encoding="utf-8")
     missing = tmp_path / "gone"
 
-    previous, where, gap = mod.previous_cycle(CYCLE, (project, missing))
-    assert previous == PREV_CYCLE
+    following, where, gap = mod.following_cycle(CYCLE, (project, missing))
+    assert following == "cyc20260917-223000"
     assert str(missing) in where and "could not be read" in where
     assert str(missing) in gap, "the root that answered nothing is reported structurally"
 
     # Nothing readable at all: the reason is the read failure, not "no record" —
     # the two are different facts and only one of them is a gap in the corpus.
-    previous, where, gap = mod.previous_cycle(CYCLE, (missing,))
-    assert previous == ""
+    following, where, gap = mod.following_cycle(CYCLE, (missing,))
+    assert following == ""
     assert "could not be read" in where and "no cycle record" not in where
     assert str(missing) in gap, (
-        "an absent root is one that answered nothing, and this is the element a "
-        "window is narrowed on (issue #2275)"
+        "an absent root is one that answered nothing, and the far bound is read from "
+        "this element"
     )
     # …and the reason is carried with it, asserted as a *shape* rather than quoted.
     # Quoting it was the first form of this line, and it reddened `test-windows`
@@ -1542,13 +1475,13 @@ def test_a_root_that_cannot_be_read_is_named_rather_than_passed_over(mod, tmp_pa
         f"{gap!r}"
     )
 
-    # A root that **is** there and was listed, holding nothing earlier, is the other
-    # fact: the corpus answered, so nothing fell short and the narrow window stands.
+    # A root that **is** there and was listed, holding nothing later, is the other
+    # fact: the corpus answered, so nothing fell short and the span stays open above.
     empty = tmp_path / "listed-and-empty"
     empty.mkdir()
-    previous, where, gap = mod.previous_cycle(CYCLE, (empty,))
-    assert previous == ""
-    assert "no cycle record before" in where
+    following, where, gap = mod.following_cycle(CYCLE, (empty,))
+    assert following == ""
+    assert "no cycle record after" in where
     assert gap == "", "listed and empty is a measurement, not a shortfall"
 
 
@@ -1568,21 +1501,25 @@ def test_the_cycle_log_override_names_one_root_or_several(mod, monkeypatch, tmp_
 
 
 def test_the_cli_reads_both_roots_named_by_the_override(mod, monkeypatch, capsys, tmp_path):
-    """The wiring, end to end: `--cycles-log` carrying two roots resolves the window
-    from the newer record, so the row is an abstain rather than a vote."""
+    """The wiring, end to end: `--cycles-log` carrying two roots resolves the span's far
+    bound from a record in the **second** one, so the row is a vote rather than an
+    abstain. The first root alone is the control, and it is a test of its own
+    (`test_a_head_pushed_past_a_corpus_with_no_later_cycle_reads_abstain`): a second
+    `_run` in one test re-installs the fakes onto the first one."""
     legacy, project = tmp_path / "legacy", tmp_path / "project"
     legacy.mkdir()
     project.mkdir()
     (legacy / "cycle-20260917-100000.md").write_text("x", encoding="utf-8")
-    (project / f"cycle-{PREV_CYCLE[3:]}.md").write_text("x", encoding="utf-8")
-    votes = FakeVotes(reviews=[], push=_push(2026, 9, 17, 22, 5))
+    (project / "cycle-20260917-223000.md").write_text("x", encoding="utf-8")
+    pushed = _push(2026, 9, 17, 22, 35)  # at or after 22:30:00, the next cycle's start
+    votes = FakeVotes(reviews=[], push=pushed)
     fresh = FakeFresh()
     _run(mod, monkeypatch, votes, fresh,
          ["1", "--cycle", CYCLE, "--cycles-log",
           os.pathsep.join([str(legacy), str(project)])])
     out = capsys.readouterr().out
-    assert "abstain" in out and PREV_CYCLE in out
-    assert str(project) in out
+    assert f"cast-vote.py 1 --cycle {CYCLE}" in out, out
+    assert "abstain" not in _rows(out), out
 
 
 def test_the_records_land_where_the_queue_reads_them(mod, tmp_path):
@@ -1691,38 +1628,6 @@ def test_the_records_land_where_the_queue_reads_them(mod, tmp_path):
     )
 
 
-def test_an_unresolvable_previous_cycle_narrows_the_window_and_says_so(
-        mod, monkeypatch, capsys, tmp_path):
-    """No record to read: the scan shrinks to this cycle's own start. That is a
-    strictly weaker reading, so it is reported as one — a narrowed window must never
-    be printed as if the clause had been applied in full."""
-    votes = FakeVotes(reviews=[], push=_push(2026, 9, 17, 22, 5))
-    fresh = FakeFresh()
-    _run(mod, monkeypatch, votes, fresh,
-         ["1", "--cycle", CYCLE, "--cycles-log", str(tmp_path)])
-    out = capsys.readouterr().out
-    assert "abstain" not in _rows(out)  # not a claim the tool cannot support
-    assert "note: the abstention window could not be widened" in out
-    # Also inferred (the lookup ran and found nothing), so the two notes meet here:
-    # the narrowed one is the stronger statement and takes the line.
-    assert "issue #2214" not in out, out[:400]
-    assert "no cycle record before" in out
-    # The other half of "narrowed, and said so": the note names the boundary that
-    # *was* checked, so a reader can still apply the clause by hand to an earlier push
-    # (the push time is on the row) instead of taking the silence for a pass.
-    assert datetime(2026, 9, 17, 22, 11, 17, tzinfo=LOCAL).isoformat(timespec="seconds") \
-        in out
-    # And it is printed *ahead* of the rows it weakens (`cyc20260926-120320` moved it
-    # there): the tail placement left it at line 39 of a queue a reader pipes through
-    # `head`, or reads only as far as the first row whose command they copy.
-    #
-    # The tree line moved in front of it on 2026-09-26 (#1635), so "ahead of the rows"
-    # is now "the line after the tree line" rather than "line 0" - the reading that
-    # matters is the order, and it is asserted as an order.
-    lines = [line for line in out.splitlines() if line.strip()]
-    assert lines[0].startswith("tree: "), lines[0]
-    assert lines[1].startswith("note: the abstention window could not be widened"), lines[:2]
-    assert out.index("could not be widened") < out.index("#1 "), out[:300]
 
 
 def test_a_narrowed_window_still_catches_this_cycles_own_push(mod, monkeypatch, capsys,
@@ -1737,622 +1642,56 @@ def test_a_narrowed_window_still_catches_this_cycles_own_push(mod, monkeypatch,
     assert "abstain" in out
 
 
-# --- the record-less cycle: the hole in the record corpus -------------------
-#
-# A cycle writes its record in §4, so a cycle that dies earlier leaves none and the
-# corpus cannot tell "no cycle ran" from "one ran and wrote nothing". `previous_cycle`
-# then answers with the *older* record and the window widens over the missing cycle's
-# work — a vote **blocked**, silently, which is the direction the clause exists to keep
-# narrow (issue #2214). The dispatches name that cycle exactly: the prompt carries the
-# cycle's own id, and the id *is* its start.
-
-#: A cycle dispatched between `PREV_CYCLE` (21:59:29) and `CYCLE` (22:11:17), with no
-#: record of its own. It is the cycle immediately before `CYCLE`, so a head it pushed is
-#: an abstain while a head pushed before it started belongs to `PREV_CYCLE` — two cycles
-#: back, and so votable.
-GAP_CYCLE = "cyc20260917-220300"
-
-
-def _dispatch_line(cycle, ts="2026-09-17T22:03:00", kind="message", role="user"):
-    """One history line, and the shell that holds it.
-
-    The real history is JSONL under `<sessions>/<session>/history[_YYMMDD].jsonl`, one
-    object per line; a message line carries the rendered prompt, which is where the
-    cycle's own id is substituted. Written through `json.dumps` so the fixture is the
-    file format rather than a hand-spelled lookalike of it.
-    """
-    body = f"## Evolution Cycle\n\nyou are cycle {cycle} of emrg-evolution-emrg-task"
-    record = {"type": kind, "content": body, "timestamp": ts}
-    if role:
-        record["role"] = role
-    return json.dumps(record)
-
-
-def _session_history(tmp_path, lines, name="history_260917.jsonl"):
-    """A session directory holding one history, and the directory it sits in."""
-    sessions = tmp_path / "sessions"
-    session = sessions / "emrg-evolution-emrg-task"
-    session.mkdir(parents=True, exist_ok=True)
-    (session / name).write_text("\n".join(lines) + "\n", encoding="utf-8")
-    return sessions
-
-
-def test_a_recordless_cycle_is_the_immediately_preceding_one_not_the_older_record(
-        mod, monkeypatch, capsys, tmp_path):
-    """The head that issue #2214 is about: pushed by the cycle *two* back, which the
-    clause lets this cycle vote on, while the records alone read it as an abstain.
-
-    The records hold one cycle, `PREV_CYCLE` (21:59:29). A cycle was dispatched at
-    22:03:00 and wrote no record, so the cycle immediately before this one began there,
-    and the window's near end is 22:03:00 rather than 21:59:29. The head below is pushed
-    at 22:01 — after `PREV_CYCLE` began, before the record-less cycle did — so it is
-    `PREV_CYCLE`'s work: two cycles back, and votable.
-    """
-    (tmp_path / "records").mkdir()
-    (tmp_path / "records" / f"cycle-{PREV_CYCLE[3:]}.md").write_text("x", encoding="utf-8")
-    _session_history(tmp_path, [_dispatch_line(GAP_CYCLE)])  # beside the records: the default
-    votes = FakeVotes(reviews=[], push=_push(2026, 9, 17, 22, 1))
-    rc = _run(mod, monkeypatch, votes, FakeFresh(), [
-        "1", "--cycle", CYCLE, "--cycles-log", str(tmp_path / "records"),
-    ])
-    out = capsys.readouterr().out
-    assert rc == 0
-    assert "abstain" not in _rows(out)
-    assert f"cast-vote.py 1 --cycle {CYCLE}" in out
 
 
-def test_the_recordless_cycle_itself_is_still_an_abstain(
-        mod, monkeypatch, capsys, tmp_path):
-    """The control, over the same two corpora: narrowing must not delete the clause.
 
-    A head pushed at 22:05 is the record-less cycle's own work, and that cycle *is* the
-    one immediately before this one — the case the precedent widened the window for. A
-    fix that stopped abstaining here would be spending exactly the vote the clause
-    exists to protect.
-    """
-    (tmp_path / "records").mkdir()
-    (tmp_path / "records" / f"cycle-{PREV_CYCLE[3:]}.md").write_text("x", encoding="utf-8")
-    _session_history(tmp_path, [_dispatch_line(GAP_CYCLE)])
-    votes = FakeVotes(reviews=[], push=_push(2026, 9, 17, 22, 5))
-    rc = _run(mod, monkeypatch, votes, FakeFresh(), [
-        "1", "--cycle", CYCLE, "--cycles-log", str(tmp_path / "records"),
-    ])
-    out = capsys.readouterr().out
-    assert rc == 0
-    assert "abstain" in out
-    assert GAP_CYCLE in out  # the cycle the window was resolved to, named on the row
-
-
-def test_a_window_whose_far_end_was_never_measured_says_so(mod):
-    """Issue #2275: the two answers that read alike, and only one of which decided the push.
-
-    `abstain_window` has two ways to end up without a previous cycle, and it treated them
-    the same — fall back to this cycle's own start, the documented *narrower* reading.
-    That is a reading of the corpus ("listed, and it holds nothing earlier") and only one
-    of the two states has a corpus that was listed: where the records could not be listed,
-    the *far end* was never measured, and the narrowed window's lower half is then all it
-    knows — a push at or after the start is inside every candidate window, a push below it
-    is a push the wider window would have decided.
-
-    So the narrowed window is kept in both states — the queue's `abstain` row for a head
-    this cycle pushed is sound and must survive, which is what the CI leg measured when a
-    first cut of this fix refused to apply a window at all — and the difference is carried
-    by `boundary_unmeasured`, the one property the counter and the poster both ask. Arms
-    (b) and (c) are the controls: a corpus that **was** listed narrows for real, and a
-    resolved boundary is not made undecided by a shortfall somewhere else.
-    """
-    # (a) the records could not be listed: the narrow window stands, its far end does not
-    unmeasured = mod.abstain_window(
-        CYCLE, "", "gone (No such file or directory) could not be read",
-        inferred=True, corpus_shortfall="gone (No such file or directory)",
-    )
-    assert unmeasured.applied is True, "this cycle's own start needs no corpus"
-    assert unmeasured.window_start_text() == mod.cycle_start(CYCLE).isoformat(timespec="seconds")
-    assert unmeasured.boundary_unmeasured is True, (
-        "the boundary above the start was never measured, and this is what both readers ask"
-    )
-    assert "gone" in unmeasured.unresolved and "2275" in unmeasured.unresolved, (
-        f"the reason must name the corpus that fell short: {unmeasured.unresolved!r}"
-    )
 
-    # (b) the control: the same absence of a previous cycle, from a corpus that **was**
-    #     listed. The narrow window stands and it *was* measured — the legitimate case
-    #     `test_check_vote_count.py`'s fixture is built on, and the one a tool that
-    #     refused every narrowed window would break
-    narrowed = mod.abstain_window(
-        CYCLE, "", f"no cycle record before {CYCLE} in /listed/and/empty", inferred=True,
-    )
-    assert narrowed.applied is True
-    assert narrowed.window_start_text() == mod.cycle_start(CYCLE).isoformat(timespec="seconds")
-    assert narrowed.boundary_unmeasured is False, (
-        "a listed corpus that answers 'nothing earlier' measured the far end"
-    )
 
-    # (c) a boundary that **was** found survives a shortfall: `previous_cycle` answers with
-    #     the newest record across every readable root, so a root that could not be listed
-    #     can only have made that boundary too early - the wide direction, which blocks
-    #     rather than credits
-    resolved = mod.abstain_window(
-        CYCLE, PREV_CYCLE, "/some/records", inferred=True,
-        corpus_shortfall="gone (No such file or directory)",
-    )
-    assert resolved.applied is True
-    assert resolved.corpus_shortfall == "gone (No such file or directory)", (
-        "a resolved window still says which corpus fell short"
-    )
-    assert resolved.boundary_unmeasured is False, (
-        "the far end is what `previous` supplied, so nothing about it is undecided"
-    )
 
 
-def test_a_dispatch_that_fills_in_the_boundary_measures_the_far_end(mod):
-    """The dispatch corpus is a measured boundary, so it may fill one in — and a window it
-    filled in is decided, while the window must go on saying which corpus it could not read
-    rather than reading as an ordinary records-only resolution (issue #2275)."""
-    unmeasured = mod.abstain_window(
-        CYCLE, "", "gone (No such file or directory) could not be read",
-        inferred=True, corpus_shortfall="gone (No such file or directory)",
-    )
-    assert unmeasured.boundary_unmeasured is True  # the state the dispatch corpus repairs
 
-    moved = mod.with_dispatches(unmeasured, CYCLE, [PREV_CYCLE])
-    assert moved.applied is True, "a dispatched id is its cycle's start, so it is exact"
-    assert moved.window_start_text() == mod.cycle_start(PREV_CYCLE).isoformat(
-        timespec="seconds"
-    )
-    assert moved.corpus_shortfall == "gone (No such file or directory)"
-    assert moved.boundary_unmeasured is False, (
-        "a dispatched id *is* the boundary, so the far end is now measured - a window that "
-        "went on refusing every push below its start would strand votes the corpus reached"
-    )
-    assert "gone" in moved.source, f"the source must name it: {moved.source!r}"
 
 
-def test_a_window_the_dispatch_corpus_moves_keeps_its_far_bound(mod):
-    """Both exits of `with_dispatches` build a **fresh** `Window`, so any field the
-    constructor is not handed is dropped silently — and the far bound is not a function of
-    the boundary being moved: the cycle *after* this one began where it began either way.
 
-    Measured 2026-10-17 on this host: the ordinary exit lost it, so a head the next cycle
-    pushed read `abstain` again — issue #2334's defect, back on the path the corpus takes
-    most often (it moves the boundary whenever a dispatched cycle is newer than the newest
-    record, which is the case the corpus exists for). The guard beside this one could not
-    catch it: it resolves a window with no `following`, so there was no far bound to lose.
-    """
-    following = "cyc20260917-223000"  # the next cycle: the span's far bound
-    window = mod.abstain_window(CYCLE, PREV_CYCLE, "/some/records", inferred=True,
-                                following=following)
-    assert window.end == mod.cycle_start(following)
-
-    # Exit 1 — a dispatched cycle between the record and this cycle's own id moves the
-    # start up to it, and the span must still end where the next cycle began.
-    moved = mod.with_dispatches(window, CYCLE, [PREV_CYCLE, GAP_CYCLE])
-    assert moved.window_start_text() == mod.cycle_start(GAP_CYCLE).isoformat(
-        timespec="seconds")
-    assert moved.end == window.end, (
-        "the far bound is the start of the cycle *after* this one, which moving the near "
-        "end does not touch"
-    )
-    assert moved.covers(datetime(2026, 9, 17, 22, 35, tzinfo=LOCAL)) is False, (
-        "22:35 local is past the next cycle's start, so that head is that cycle's work "
-        "however far up the near end was moved"
-    )
-
-    # Exit 2 — the same move where the record corpus could not be read at all, which is
-    # the exit that repairs an unmeasured start.
-    unmeasured = mod.abstain_window(
-        CYCLE, "", "gone (No such file or directory) could not be read",
-        inferred=True, corpus_shortfall="gone (No such file or directory)",
-        following=following,
-    )
-    assert unmeasured.boundary_unmeasured is True
-    repaired = mod.with_dispatches(unmeasured, CYCLE, [PREV_CYCLE])
-    assert repaired.end == mod.cycle_start(following), (
-        "supplying the start the records could not measure says nothing about the far end"
-    )
-
-
-def test_a_dispatch_older_than_the_record_does_not_move_the_window(mod):
-    """The refinement runs one way. Where a record exists it is the answer, so an id
-    from before it — a stale quotation, a re-delivered prompt of an older cycle — must
-    not drag a resolved window backwards and un-abstain work the record covers."""
-    window = mod.abstain_window(CYCLE, PREV_CYCLE, "/some/records")
-    older = "cyc20260917-210000"
-    assert mod.cycle_start(older) < window.start
-    for ids in ([older], [older, "cyc20260917-200000"], [], ["cyc20260917-230000"]):
-        moved = mod.with_dispatches(window, CYCLE, ids)
-        assert moved.window_start_text() == window.window_start_text(), ids
-    # And the direction it does take: a dispatched cycle between the record and this
-    # cycle's own id is the new near end.
-    moved = mod.with_dispatches(window, CYCLE, [PREV_CYCLE, GAP_CYCLE])
-    assert moved.window_start_text() != window.window_start_text()
-    assert moved.window_start_text() == mod.cycle_start(GAP_CYCLE).isoformat(
-        timespec="seconds")
-
-
-def test_a_corpus_that_reaches_the_boundary_confirms_it_and_clears_the_caveat(mod):
-    """Issue #2216, composed with #2214's disclosure: two of the three cases agree on the
-    boundary and differ on what may be claimed about it.
-
-    An id **equal** to the records' own answer is the same cycle, so the corpus has
-    confirmed that nothing was dispatched between it and now — the missing cycle #2214
-    is about is one this corpus would have named — and the caveat a records-only
-    lookup owes its reader is not owed. An id **older** than the boundary reaches no gap
-    above it (a stale quotation, a re-delivered prompt) and must leave the caveat
-    standing. An empty corpus is the absent one: nothing was read to confirm with.
-    """
-    window = mod.abstain_window(CYCLE, PREV_CYCLE, "/some/records", inferred=True)
-    assert window.inferred is True
 
-    confirmed = mod.with_dispatches(window, CYCLE, [PREV_CYCLE])
-    assert confirmed.window_start_text() == window.window_start_text()
-    assert confirmed.inferred is False, (
-        "the corpus named the very cycle the records did - that is a confirmation, not a "
-        "silence, so the note has nothing left to disclose"
-    )
 
-    older = "cyc20260917-210000"
-    assert mod.cycle_start(older) < window.start
-    assert mod.with_dispatches(window, CYCLE, [older]).inferred is True, (
-        "an id older than the boundary does not reach the gap above it"
-    )
-    assert mod.with_dispatches(window, CYCLE, []).inferred is True
-    assert mod.with_dispatches(window, CYCLE, [CYCLE]).inferred is True, (
-        "a cycle is not its own predecessor: the id must be strictly earlier"
-    )
-    # The direction that moves the window already carried the flag down with it.
-    moved = mod.with_dispatches(window, CYCLE, [PREV_CYCLE, GAP_CYCLE])
-    assert moved.window_start_text() != window.window_start_text()
-    assert moved.inferred is False
 
 
-def test_a_dispatch_naming_the_records_own_cycle_suppresses_the_note(
-        mod, monkeypatch, capsys, tmp_path):
-    """The same fact at the report, which is where the reader meets it.
 
-    Measured while resolving #2215/#2217 on 2026-10-13: the live corpus holds 1798
-    dispatched ids and the newest one before the measuring cycle was the record's own
-    answer, so before this every run of a checkout with sessions printed the note. A
-    caveat on every run is how the caveat that matters gets skimmed.
 
-    The control is `test_an_inferred_window_names_the_instant_it_used_and_its_blind_spot`
-    below, which runs the same report with no sessions at all: there the id is absent,
-    nothing confirms, and the note must still print.
-    """
-    (tmp_path / "records").mkdir()
-    (tmp_path / "records" / f"cycle-{PREV_CYCLE[3:]}.md").write_text("x", encoding="utf-8")
-    _session_history(tmp_path, [_dispatch_line(PREV_CYCLE)])
-    votes = FakeVotes(reviews=[], push=_push(2026, 9, 17, 23, 0))
-    rc = _run(mod, monkeypatch, votes, FakeFresh(), [
-        "1", "--cycle", CYCLE, "--cycles-log", str(tmp_path / "records"),
-    ])
-    out = capsys.readouterr().out
-    assert rc == 0
-    assert "issue #2214" not in out, (
-        "the corpus named the record's own cycle, so the boundary was confirmed and there "
-        f"is no gap to disclose: {out[:400]}"
-    )
-    assert "note: the own-window" not in out, out[:400]
 
 
-def test_the_dispatch_reader_takes_the_id_the_prompt_carries(mod, tmp_path):
-    """How the id is read, and what is refused.
 
-    The marker is a substring of anything that *quotes* a prompt — this file was
-    measured by grepping one — so a line is accepted only when it parses to a `user`
-    message. A tool result echoing the same text carries the marker and the id and is
-    not a dispatch.
-    """
-    sessions = _session_history(tmp_path, [
-        _dispatch_line("cyc20260917-220300"),
-        json.dumps({"type": "tool_result", "content": _dispatch_line("cyc20260917-230000")}),
-        "not json at all",
-        _dispatch_line("cyc20260917-211500", kind="message", role="assistant"),
-    ])
-    ids, unreadable = mod.dispatch_ids((sessions,))
-    assert ids == ["cyc20260917-220300"]
-    assert unreadable == []
-    # An absent directory is named, not raised: a checkout with no sessions is a state,
-    # and the caller must be able to tell it from a directory it failed to read.
-    ids, unreadable = mod.dispatch_ids((tmp_path / "nowhere",))
-    assert ids == []
-    assert unreadable and "nowhere" in unreadable[0]
-
-
-def test_the_dispatch_corpus_defaults_to_the_records_sibling(mod, tmp_path):
-    """One root, two corpora: pointing `--cycles-log` at a corpus of your own answers
-    the dispatches from beside it, so a test never reads the machine's real sessions and
-    a host needs no second path to keep in step."""
-    root = tmp_path / "records"
-    assert mod.resolve_session_dirs(None, (root,)) == (tmp_path / "sessions",)
-    assert mod.resolve_session_dirs("/elsewhere", (root,)) == (Path("/elsewhere"),)
-
-
-def test_a_corpus_that_is_there_and_cannot_be_read_is_not_an_absent_one(mod, tmp_path):
-    """Issue #2224: an absent corpus is a state; a corpus that failed to open is a
-    measurement that failed, and the two must not read the same.
-
-    `dispatch_ids` has always produced the second half of that distinction in its
-    `unreadable` list, and every caller dropped it — so the disclosure a records-only
-    window owes its reader was printed whether the corpus was absent (the CI shape, and
-    documented as *not* a failure) or unreadable (ids silently incomplete). Measured
-    2026-10-14 before this test: an absent corpus and a regular file at the corpus path
-    produced byte-identical output.
-
-    The membership test is the filesystem, not the error text: `exists()`, so that a file
-    where a directory was expected counts as *there* (it is not absent, and it is not
-    readable as a corpus either).
-    """
-    records = tmp_path / "records"
-    records.mkdir()
-    (records / f"cycle-{PREV_CYCLE[3:]}.md").write_text("x", encoding="utf-8")
-    # A corpus that is present and cannot be listed: a regular file at its path.
-    a_file = tmp_path / "notdir"
-    a_file.write_text("not a directory\n", encoding="utf-8")
-    absent = tmp_path / "nowhere"
-
-    for state, where in (("absent", absent), ("unreadable", a_file)):
-        window = mod.own_window(CYCLE, None, str(records), str(where))
-        assert window.inferred is True, (state, window)
-        clause = window.inferred_clause()
-        if state == "absent":
-            assert window.dispatch_unread == "", (state, window.dispatch_unread)
-            assert "could not be read" not in clause, clause
-        else:
-            assert window.dispatch_unread, "the reason a present corpus failed is kept"
-            assert "could not be read" in clause, clause
-            assert str(where) in clause, "the corpus that failed is named, not implied"
-
-    # And the distinction reaches the reader through the note it is printed in.
-    as_text = {
-        state: mod.window_note(mod.own_window(CYCLE, None, str(records), str(where)))
-        for state, where in (("absent", absent), ("unreadable", a_file))
-    }
-    assert as_text["absent"] != as_text["unreadable"], (
-        "the note must not read the same for a corpus that is not there and one that "
-        "could not be opened"
-    )
-    assert "could not be read" not in as_text["absent"], as_text["absent"]
 
 
-def test_the_corpus_membership_test_is_the_filesystem_not_the_error_text(mod, tmp_path):
-    """A unit check on `corpus_read_failure`, because its one rule is the whole point.
 
-    `exists()` and not `is_dir()`: an empty directory that *is* there is a corpus with no
-    dispatches (a state), a file at the path is a corpus that cannot be opened (a
-    failure), and a path with nothing at it is the CI shape (a state, silent).
-    """
-    empty_dir = tmp_path / "empty"
-    empty_dir.mkdir()
-    a_file = tmp_path / "afile"
-    a_file.write_text("x", encoding="utf-8")
-
-    absent = tmp_path / "nowhere"
-    assert mod.corpus_read_failure((absent,), [f"{absent} (No such file)"]) == ""
-    assert mod.corpus_read_failure((empty_dir,), []) == ""
-    assert mod.corpus_read_failure((a_file,), [f"{a_file} (Not a directory)"]) == (
-        f"{a_file} (Not a directory)"
-    ), "a path that exists is not absent, whatever the error says"
-    # Two corpora, one unreadable: the reason survives the other half being fine.
-    assert mod.corpus_read_failure(
-        (empty_dir, a_file), [f"{a_file} (Not a directory)"]
-    ) == f"{a_file} (Not a directory)"
-
-
-def test_a_mixed_set_reports_only_the_corpus_that_is_there(mod, tmp_path):
-    """Issue #2224, the mixed case: the absent member is not the failure.
-
-    The two tests above pin the homogeneous sets. This is the set that mixes them, and the
-    shape the helper had wrong: the filesystem test was applied to the **set**, so a corpus
-    that is there made the guard pass and the *absent* member's reason - which
-    `dispatch_ids` records, and whose docstring calls absence "not an error" - came back as
-    the reason a corpus could not be read. The clause then reads "The dispatch corpus could
-    not be read (<a path with nothing at it>), so no dispatch was consulted either" while
-    the present corpus was walked, which is three false statements in the one sentence this
-    change exists to make true - and master printed the silent clause for that set.
-
-    Driven through `dispatch_ids`' **real output**, never a hand-written list, because that
-    output is exactly where the absent member's reason lives: a list written for the purpose
-    omits it, which is why the homogeneous tests above cannot see this.
-    """
-    records = tmp_path / "records"
-    records.mkdir()
-    (records / f"cycle-{PREV_CYCLE[3:]}.md").write_text("x", encoding="utf-8")
-    present = tmp_path / "present"
-    present.mkdir()
-    absent = tmp_path / "nowhere"
-    a_file = tmp_path / "notdir"
-    a_file.write_text("not a directory\n", encoding="utf-8")
-
-    for seats in ((present, absent), (absent, present)):
-        _ids, unreadable = mod.dispatch_ids(seats)
-        assert any(str(absent) in reason for reason in unreadable), (
-            "the premise: `dispatch_ids` records the absent member in `unreadable`"
-        )
-        assert mod.corpus_read_failure(seats, unreadable) == "", (
-            "a set that also holds a corpus that is there must not report the path with "
-            "nothing at it as a measurement that failed"
-        )
 
-    # The other direction, so a helper that always answered "" for a mixed set cannot
-    # pass: a corpus that is there and refuses to list is named whatever it is mixed with.
-    for seats in ((a_file, absent), (absent, a_file), (present, a_file), (a_file, present)):
-        _ids, unreadable = mod.dispatch_ids(seats)
-        failure = mod.corpus_read_failure(seats, unreadable)
-        assert str(a_file) in failure, (seats, unreadable)
-        assert str(absent) not in failure, (seats, unreadable)
-
-    # A prefix collision is not a match: with `a` absent and a file at `ab`, a bare
-    # `startswith` on the absent path would drop `ab`'s genuine reason.
-    prefixed_absent = tmp_path / "a"
-    prefixed_file = tmp_path / "ab"
-    prefixed_file.write_text("x", encoding="utf-8")
-    seats = (prefixed_absent, prefixed_file)
-    _ids, unreadable = mod.dispatch_ids(seats)
-    failure = mod.corpus_read_failure(seats, unreadable)
-    assert f"{prefixed_file} (" in failure, unreadable
-    assert f"{prefixed_absent} (" not in failure, unreadable
-
-    # And the clause the reader is shown follows the same reading.
-    mixed = os.pathsep.join([str(present), str(absent)])
-    clause = mod.own_window(CYCLE, None, str(records), mixed).inferred_clause()
-    assert "could not be read" not in clause, clause
-    assert mod.own_window(CYCLE, None, str(records), mixed).dispatch_unread == ""
-
-
-def test_an_absent_corpus_is_never_disclosed_whatever_its_name_carries(mod, tmp_path):
-    """The rule the whole helper exists for, stated as a property over the naming.
-
-    `corpus_read_failure` may name a corpus that is there and would not open; it may
-    **never** name one that is not there. Every test above checks that on a path with an
-    ordinary name, and a reason string is `"<path> (<error>)"` - so a path that itself
-    carries a `" ("` makes the two shapes overlap, and the membership test is where that
-    shows. Measured 2026-10-14 (cycle `cyc20261014-081405`): the comparison suggested on
-    issue #2224's PR thread, `reason.split(" (", 1)[0] == directory`, satisfies every
-    ordinary case above and **discloses an absent directory** whose name carries the
-    parenthetical, which is the defect #2224 removed. It was suggested by two reviewers
-    and repeated by an approving vote, so prose alone is what stood between this tree and
-    that regression; this test is what stands there instead.
-    """
-    absent_paren = tmp_path / "a (copy)"  # not on disk, and its name holds " ("
-    (tmp_path / "z").write_text("x", encoding="utf-8")  # there, unlistable
-    (tmp_path / "w").mkdir()                           # there, an empty corpus
-    others = {"a file, unlistable": tmp_path / "z", "an empty corpus": tmp_path / "w",
-              "nothing there, an ordinary name": tmp_path / "v"}
-    for label, other in others.items():
-        seats = (absent_paren, other)
-        _ids, unreadable = mod.dispatch_ids(seats)
-        assert any(str(absent_paren) in reason for reason in unreadable), (
-            "the premise, with " + label + ": `dispatch_ids` records the absent member",
-            unreadable,
-        )
-        failure = mod.corpus_read_failure(seats, unreadable)
-        assert str(absent_paren) not in failure, (
-            f"an absent corpus directory was reported as one that could not be read, "
-            f"beside {label}: {failure!r}"
-        )
 
-    # The other direction, so a helper that named nothing at all cannot pass: the present
-    # file beside that absent directory is still disclosed, by its own path.
-    present_file = tmp_path / "z"
-    failure = mod.corpus_read_failure(
-        (absent_paren, present_file),
-        [f"{absent_paren} (No such file)", f"{present_file} (Not a directory)"],
-    )
-    assert failure == f"{present_file} (Not a directory)", failure
 
 
-def test_the_dispatch_corpus_comes_from_the_emrg_root_that_owns_the_records(mod, tmp_path):
-    """Issue #2222: a record root's corpus is the `.emrg` root's `sessions`, not the
-    directory beside the root.
 
-    The derivation looked beside each record root, which was right while the corpus had
-    one root (`<checkout>/.emrg/memory` → `<checkout>/.emrg/sessions`). #2221 made the
-    default several roots, one of them a session's (`.../.emrg/sessions/<id>/memory`),
-    whose sibling — `<id>/sessions` — was never a corpus at all. So the reading invented
-    a directory and then reported it as one it could not read.
 
-    Both scopes belong to the same `.emrg` root and must answer with the same directory,
-    once: two entries naming one corpus is a reading that looks like two.
-    """
-    checkout = tmp_path / "proj"
-    project_root = checkout / ".emrg" / "memory"
-    session_root = checkout / ".emrg" / "sessions" / "s1" / "memory"
-    project_root.mkdir(parents=True)
-    session_root.mkdir(parents=True)
-
-    assert mod.resolve_session_dirs(None, (project_root,)) == (
-        checkout / ".emrg" / "sessions",
-    )
-    assert mod.resolve_session_dirs(None, (session_root,)) == (
-        checkout / ".emrg" / "sessions",
-    ), "a session root's corpus is its `.emrg` root's sessions, not a directory beside it"
-    assert mod.resolve_session_dirs(None, (project_root, session_root)) == (
-        checkout / ".emrg" / "sessions",
-    ), "one corpus named by two roots is one directory, not two"
-
-
-def test_a_session_scoped_corpus_is_read_rather_than_lost(mod, tmp_path):
-    """The other half of the same mistake, and the one that loses dispatches outright.
-
-    A caller naming a session's memory directory as its record corpus had its dispatches
-    read from `<session>/sessions` — absent — so the window silently fell back to the
-    records alone, with the corpus two levels up never consulted and no fault printed.
-    The histories are written where `dispatch_ids` looks, and they are found now.
-    """
-    checkout = tmp_path / "proj"
-    session_root = checkout / ".emrg" / "sessions" / "s1" / "memory"
-    session_root.mkdir(parents=True)
-    history = checkout / ".emrg" / "sessions" / "s1" / "history_260917.jsonl"
-    history.write_text(
-        json.dumps({
-            "type": "message", "role": "user", "timestamp": "2026-09-17T22:03:00",
-            "content": "## Evolution Cycle\n\ncycle cyc20260917-220300 of the task",
-        }) + "\n",
-        encoding="utf-8",
-    )
-
-    dirs = mod.resolve_session_dirs(None, (session_root,))
-    assert dirs == (checkout / ".emrg" / "sessions",), dirs
-    ids, unreadable = mod.dispatch_ids(dirs)
-    assert ids == ["cyc20260917-220300"], ids
-    assert unreadable == [], unreadable
-
-
-def test_the_sessions_override_reaches_the_window(mod, monkeypatch, capsys, tmp_path):
-    """`--sessions-dir` / `$EMRG_SESSIONS_DIR` name the dispatch corpus somewhere else, and
-    both have to reach `main`'s reading rather than only the parser: the flag is the
-    remedy when the histories do not sit beside the records, so a wiring mistake would
-    leave the fix silently off for the callers who need it. Neither the records' sibling
-    nor the real machine's sessions is read here — the override is what is passed."""
-    records = tmp_path / "records"
-    records.mkdir()
-    (records / f"cycle-{PREV_CYCLE[3:]}.md").write_text("x", encoding="utf-8")
-    elsewhere = _session_history(tmp_path / "elsewhere", [_dispatch_line(GAP_CYCLE)])
-    argv = ["1", "--cycle", CYCLE, "--cycles-log", str(records)]
-
-    # Each run installs both seams, and `_install` binds its fake to the sibling it
-    # replaces by calling the *patched* name — so a second run over the first run's seams
-    # would hand the new fake the old fake as its "real" module (`'FakeVotes' object has
-    # no attribute 'Verdict'`), which is a fact about this fixture and not about the flag.
-    # A nested context undoes exactly what that run installed. It is not `undo()`:
-    # `monkeypatch.undo()` undoes the autouse ledger seam too, and the second run then
-    # reads the machine's `~/.emrg/rants.jsonl` — absent on a CI runner, where the tool
-    # answers `unmeasurable` and exits 2, and present on the host that wrote this, where
-    # it exits 0. Measured: run 38411916623, both legs, 1 failed / 4976 passed.
-    with monkeypatch.context() as first:
-        rc = _run(mod, first, FakeVotes(reviews=[], push=_push(2026, 9, 17, 22, 1)),
-                  FakeFresh(), argv + ["--sessions-dir", str(elsewhere)])
-    assert rc == 0
-    assert "abstain" not in _rows(capsys.readouterr().out)
-
-    monkeypatch.setenv("EMRG_SESSIONS_DIR", str(elsewhere))
-    rc = _run(mod, monkeypatch, FakeVotes(reviews=[], push=_push(2026, 9, 17, 22, 1)),
-              FakeFresh(), argv)
-    # The seam, not only the exit code: an exit code is a fact about the machine as much
-    # as about the flag (that is exactly how the run above went green here and red on
-    # CI), so the property this test rests on — every invocation read the ledger through
-    # the fixture — is asserted directly, and holds on a host with the file or without it.
-    assert isinstance(mod.open_rant_rows, FakeLedger), (
-        "this test ran the tool against the machine's own ~/.emrg/rants.jsonl: the ledger "
-        "seam was undone, so the verdict below is about this host's files, not the flag"
-    )
-    assert rc == 0
-    assert "abstain" not in _rows(capsys.readouterr().out)
+
+
+
+
+
+
+
+
 
 
 # ── one window, three carriers (issue #2218) ────────────────────────────────
 #
 # The own-window clause is decided once and acted on **thrice**: this tool prints
 # `vote` / `abstain` from it, `cast-vote.py` refuses to *post* on it, and
-# `check-vote-count.py` voids a posted vote on it. Resolve it in one carrier from the
-# records alone while another has already moved it past a record-less cycle, and the
-# same head reads `vote` in the queue and is refused at the poster -- a vote lost to an
-# arithmetic difference between two readings of one rule rather than to the clause.
-# Measured 2026-10-14, after #2217 fixed the queue's half and left both siblings on the
-# records-only boundary: it is too early for **20** of this corpus's **350** cycle
-# records. `own_window` is now the single producer; these two tests are the comparison
-# that keeps the carriers from drifting apart again.
+# `check-vote-count.py` voids a posted vote on it. Resolve it differently in one carrier
+# — a bound, or an identity reading the others do not make — and the same head reads
+# `vote` in the queue and is refused at the poster, which is a vote lost to an arithmetic
+# difference between two readings of one rule rather than to the clause (issue #2218,
+# measured 2026-10-14: both siblings read a boundary the queue had already moved).
+# `own_window` is now the single producer; the test below is the comparison that keeps
+# the carriers from drifting apart again.
 
 
 def _load_sibling(module_name, filename):
@@ -2371,46 +1710,8 @@ def _load_sibling(module_name, filename):
     return module
 
 
-def _gap_corpus(tmp_path):
-    """The two corpora of the shape issue #2214 is about, and the record directory.
-
-    `records` holds the cycle *two* back (`PREV_CYCLE`, 21:59:29). A cycle was dispatched
-    at 22:03:00 (`GAP_CYCLE`) and wrote no record, so the cycle immediately before
-    `CYCLE` (22:11:17) is the record-less one -- and the record corpus cannot say so.
-    The sessions go beside the records, which is the default the tool derives.
-    """
-    records = tmp_path / "records"
-    records.mkdir()
-    (records / f"cycle-{PREV_CYCLE[3:]}.md").write_text("x", encoding="utf-8")
-    _session_history(tmp_path, [_dispatch_line(GAP_CYCLE)])
-    return records
-
-
-def test_own_window_resolves_the_boundary_from_the_dispatches(mod, tmp_path):
-    """The producer's own half: the boundary the dispatches give, and the disclosure
-    cleared along with it.
 
-    `previous_cycle` reads records, so a cycle that reached no §4 leaves none and the
-    boundary lands on the record *before* it (issue #2214). `with_dispatches` moves it
-    onto the dispatched cycle -- whose id is its own start, so the boundary is exact
-    rather than estimated -- and `inferred` goes with it, because a corpus that reached
-    the boundary confirmed it rather than merely failing to extend it.
-    """
-    records = _gap_corpus(tmp_path)
-    window = mod.own_window(CYCLE, None, str(records), None)
-    assert window.start == mod.cycle_start(GAP_CYCLE), window.source
-    assert GAP_CYCLE in window.source
-    assert window.inferred is False, (
-        "the dispatch corpus named the boundary, so the note a records-only resolution "
-        f"owes its reader is not owed here: {window.source}"
-    )
 
-    # The control, over the same records and no sessions at all: the window is the
-    # records' one and says so. Without it the assertion above would pass on a producer
-    # that ignored `--cycles-log` and answered the gap from nowhere.
-    window = mod.own_window(CYCLE, None, str(records), str(tmp_path / "no-sessions"))
-    assert window.start == mod.cycle_start(PREV_CYCLE), window.source
-    assert window.inferred is True
 
 
 class _CarrierVerdict:
@@ -2430,33 +1731,37 @@ def __init__(self, push_time):
 
 
 def test_the_three_carriers_read_one_window(mod, tmp_path):
-    """Issue #2218, as a comparison rather than a claim: same corpora, two heads, three
+    """Issue #2218, as a comparison rather than a claim: same corpus, two heads, three
     verdicts, and the queue's own reading is the one the other two must reproduce.
 
     Both instants are driven through both siblings. A pair that only compared the head
     the clause lets through would pass on a tool that never applied it, and one that only
     compared the head it refuses would pass on a tool that refused everything -- so the
     two are asserted to fall on *opposite* sides first, and then each carrier is held to
-    the side the queue put it on. The head at 22:01 is the work of `PREV_CYCLE`, two
-    cycles back and votable; the one at 22:05 is `GAP_CYCLE`'s own, which is the cycle
-    immediately before this one and therefore this cycle's own.
+    the side the queue put it on. The corpus holds the cycle that followed `CYCLE`
+    (22:30:00), so the head at 22:15 is inside this cycle's own run (which starts at
+    22:11:17) and the one at 22:35 (at or after that cycle's start) belongs to the cycle
+    that followed — the far bound issue #2334 added.
     """
-    records = _gap_corpus(tmp_path)
+    records = tmp_path / "records"
+    records.mkdir()
+    (records / "cycle-20260917-223000.md").write_text("x", encoding="utf-8")
     counter = _load_sibling("check_vote_count_carrier", "check-vote-count.py")
     poster = _load_sibling("cast_vote_carrier", "cast-vote.py")
 
-    window = mod.own_window(CYCLE, None, str(records), None)
-    assert window.start == mod.cycle_start(GAP_CYCLE), window.source
+    window = mod.own_window(CYCLE, str(records))
+    assert window.start == mod.cycle_start(CYCLE), window.source
+    assert window.end == mod.cycle_start("cyc20260917-223000"), window.source
 
-    heads = [_push(2026, 9, 17, 22, 1), _push(2026, 9, 17, 22, 5)]
-    wanted = {mod.instant(head) >= window.start for head in heads}
+    heads = [_push(2026, 9, 17, 22, 15), _push(2026, 9, 17, 22, 35)]
+    wanted = {window.covers(mod.instant(head)) for head in heads}
     assert wanted == {False, True}, (
         "the fixture must put one head on each side of the window, or the loop below "
         "measures one direction only"
     )
 
     for head in heads:
-        want = mod.instant(head) >= window.start
+        want = window.covers(mod.instant(head))
         counted, why = counter.own_head_window(
             CYCLE, push_time=head, push_time_exact=True, cycles_log=str(records)
         )
@@ -2654,84 +1959,23 @@ def test_the_json_document_keeps_its_shape_and_carries_the_same_fact(
     assert payload[0]["tree"] == str(REPO_ROOT)
     assert payload[0]["branch"] == "feature/x"
     assert "tree: " not in out, "the prose line must not be emitted into the JSON document"
-def test_an_inferred_window_names_the_instant_it_used_and_its_blind_spot(
-        mod, monkeypatch, capsys, tmp_path
-):
-    """Issue #2214: here the clause *was* applied, and the row still cannot show from
-    where.
-
-    The boundary is looked up in the `cycle-*.md` records, so a cycle that ran and wrote
-    none is found nowhere: the resolver lands on the record before it and the window
-    reaches further back than the clause does, so a head pushed inside that gap reads
-    `abstain` where it was votable. Measured 2026-10-13 — two such cycles in one day
-    (`cyc20261013-150748`, `cyc20261013-194608`), the window starting at 17:17:21 where
-    the cycle before the measuring one began at 19:46:08, and a head pushed at 19:32:47
-    inside the gap.
-
-    Silence is exactly how a full window reads, so this state has to name the instant it
-    used. The remedy is *not* the reader's — they cannot see the missing cycle either —
-    which is why the sentence states the gap instead of printing a flag.
-    """
-    (tmp_path / f"cycle-{PREV_CYCLE[3:]}.md").write_text("x", encoding="utf-8")
-    votes = FakeVotes(reviews=[], push=_push(2026, 9, 17, 22, 30))
-    fresh = FakeFresh()
-    rc = _run(mod, monkeypatch, votes, fresh,
-              ["1", "--cycle", CYCLE, "--cycles-log", str(tmp_path)])
-    out = capsys.readouterr().out
 
-    assert rc == 0
-    assert "issue #2214" in out
-    # The instant, not just the id: the width is the fact being disclosed, and the id
-    # alone does not give one to a reader who does not convert ids by hand.
-    assert mod.cycle_start(PREV_CYCLE).isoformat(timespec="seconds") in out, out[:400]
-    assert PREV_CYCLE in out
-    lines = [line for line in out.splitlines() if line.strip()]
-    assert lines[0].startswith("tree: "), lines[0]
-    assert lines[1].startswith(
-        "note: the own-window clause was read off the cycle records"), lines[:2]
-    assert out.index("issue #2214") < out.index("#1 "), out[:400]
-    # The row itself is unchanged: this note says where the window came from, it does
-    # not move a verdict.
-    assert "abstain" in out
 
 
-def test_the_inferred_window_note_stays_out_of_the_json_document(
-        mod, monkeypatch, capsys, tmp_path
-):
-    """The fact rides as fields — `vote_window_start` already carries the instant the
-    note exists to disclose — and a prose line ahead of the list would break every
-    machine consumer instead of warning them."""
-    (tmp_path / f"cycle-{PREV_CYCLE[3:]}.md").write_text("x", encoding="utf-8")
-    votes = FakeVotes(reviews=[], push=_push(2026, 9, 17, 22, 30))
-    fresh = FakeFresh()
-    _run(mod, monkeypatch, votes, fresh,
-         ["1", "--cycle", CYCLE, "--cycles-log", str(tmp_path), "--json"])
-    out = capsys.readouterr().out
-
-    payload = json.loads(out)  # a prose line here raises, which is the assertion
-    assert payload[0]["vote_window_start"] == \
-        mod.cycle_start(PREV_CYCLE).isoformat(timespec="seconds")
-    assert "issue #2214" not in out, out[:400]
-
 
 def test_a_windowed_run_prints_no_such_note(mod, monkeypatch, capsys):
-    """The control: with `--cycle` and a previous cycle in hand the clause *is*
-    applied in full, and a note printed anyway would be a claim about a gap that is not
-    there — the reader would learn to skim the line that matters."""
+    """The control: with `--cycle` naming an instant the clause *is* applied, and a note
+    printed anyway would be a claim about a gap that is not there — the reader would
+    learn to skim the line that matters."""
     votes = FakeVotes(reviews=[])
     fresh = FakeFresh()
-    _run(mod, monkeypatch, votes, fresh, ["1", "--cycle", CYCLE, "--prev-cycle",
-                                          "cyc20260917-221117"])
+    _run(mod, monkeypatch, votes, fresh, ["1", "--cycle", CYCLE])
     out = capsys.readouterr().out
 
     assert "no --cycle was given" not in out, out[:300]
-    assert "could not be widened" not in out, out[:300]
-    # And the note a *records-only* resolution prints is the other half of this control:
-    # the caller named the boundary, so the tool has no resolution of its own to
-    # disclose, and a line printed anyway is how the line that matters gets skimmed.
-    assert "issue #2214" not in out, out[:400]
-    # Same move as above: the row is the first line after the tree line, and no
-    # window note sits between them.
+    assert "the own-window clause was NOT applied" not in out, out[:300]
+    # The row follows the tree line with nothing printed between them: a note here would
+    # sit ahead of the row it weakens, which is where this family never puts one.
     lines = [line for line in out.splitlines() if line.strip()]
     assert lines[0].startswith("tree: "), lines[0]
     assert lines[1].startswith("#1 "), lines[:2]

From 6835d652d983dba683bbc724208a863dfbb3f34e Mon Sep 17 00:00:00 2001
From: EMRG Evolution <emrg@argszero.dev>
Date: Sat, 17 Oct 2026 09:27:04 +0800
Subject: [PATCH 2/2] emrg: the deleted half of the abstain clause stops being
 stated as the rule (#2338)

---
 scripts/cast-vote.py                |  8 +++++---
 scripts/check-merge-freshness.py    | 15 ++++++++-------
 scripts/check-vote-count.py         | 21 +++++++++++----------
 scripts/review-queue.py             |  5 +++--
 tests/test_check_merge_freshness.py |  2 +-
 tests/test_check_vote_count.py      | 14 +++++---------
 6 files changed, 33 insertions(+), 32 deletions(-)

diff --git a/scripts/cast-vote.py b/scripts/cast-vote.py
index e9ba33dc..9a3774e6 100644
--- a/scripts/cast-vote.py
+++ b/scripts/cast-vote.py
@@ -114,9 +114,11 @@
 The abstention clause, asked where the vote is spent
 ----------------------------------------------------
 The merge rules say what a vote *is*; until 2026-09-18 nothing said **who may cast
-one** (issue #1408). The clause is *a cycle does not vote on a head it pushed*, and
-the cycle immediately before this one counts as one's own — because every cycle on a
-host is the same instance running again. `review-queue.py` owns that reading, and
+one** (issue #1408). The clause is *a cycle does not vote on a head it pushed*, read
+against the cycle's own run — from its own start to the start of the cycle that
+follows it. The host struck the wider reading out on 2026-10-16T22:18:15, so a head
+the cycle *before* this one pushed belongs to whoever made it and is votable.
+`review-queue.py` owns that reading, and
 `uv run --no-sync python3 scripts/review-queue.py --cycle <id>` reports such a head as an
 `abstain` row.
 
diff --git a/scripts/check-merge-freshness.py b/scripts/check-merge-freshness.py
index 2ffa79ed..a9b97310 100644
--- a/scripts/check-merge-freshness.py
+++ b/scripts/check-merge-freshness.py
@@ -895,9 +895,10 @@ def _remedy(pr: int, kind: str, price: Price, run_id: str = "") -> str:
 
     "Nothing to void" is a statement about votes already cast, and it was read as
     "free" - which is a different claim, and false: the push moves the head into the
-    abstention window of the cycle that makes it *and of the cycle after that one*,
-    so the first vote the head can collect comes two cycles later than it otherwise
-    would. Measured 2026-09-26 (`cyc20260926-155041`): that cycle followed this very
+    abstention window of the cycle that makes it — that cycle's own run, and only it
+    (the host struck the wider reading out on 2026-10-16T22:18:15) — so the first vote
+    the head can collect comes one cycle later than it otherwise would.
+    Measured 2026-09-26 (`cyc20260926-155041`): that cycle followed this very
     sentence on #1638 and then could not vote on the head it had pushed -
     `cast-vote.py` refused it `own-head-window` - when the pre-refresh head was one
     its window no longer covered. The zero-vote branch therefore names the trade
@@ -920,10 +921,10 @@ def _remedy(pr: int, kind: str, price: Price, run_id: str = "") -> str:
                 "not a rebase: a rebase of a pushed branch is refused as non-fast-forward, "
                 "and publishing one needs the force-push this project forbids. Nothing to "
                 "*void* is not nothing to *lose*: the push puts the head inside the "
-                "abstention window of the cycle that makes it and of the cycle after that "
-                "one - a cycle neither votes on nor merges a head it pushed, and the window "
-                "immediately before it counts as its own - so the earliest vote this head "
-                "can collect is from the cycle after next. If this cycle would have cast "
+                "abstention window of the cycle that makes it - a cycle neither votes on "
+                "nor merges a head it pushed, and that window is the cycle's own run - so "
+                "the earliest vote this head can collect is from the cycle after this one. "
+                "If this cycle would have cast "
                 "that first vote, do not push: measure the tree this merge would land "
                 f"(`{RUNNER} scripts/check-merge-plan-suite.py <PR>`) and the head does not move, "
                 "leaving the next cycle free to vote on it"
diff --git a/scripts/check-vote-count.py b/scripts/check-vote-count.py
index 642b0dfa..be727a18 100644
--- a/scripts/check-vote-count.py
+++ b/scripts/check-vote-count.py
@@ -61,9 +61,10 @@
 Who may cast one of those votes
 -------------------------------
 The rule counts *different cycles* and never said who is allowed to be one of them.
-The missing half — **a cycle abstains on a head it pushed**, and on the head pushed by
-the cycle immediately before it, because every cycle on a host is the same instance
-running again — is refused at post time by `cast-vote.py` (issue #1408). That refusal
+The missing half — **a cycle abstains on a head it pushed**, read against the cycle's
+own run: from its own start to the start of the cycle that follows it, the narrower
+reading the host ruled to on 2026-10-16T22:18:15 — is refused at post time by
+`cast-vote.py` (issue #1408). That refusal
 is not where the count is read, so it left a hole of exactly the shape this file
 exists to close: a vote posted straight with `gh pr review` (the form the template
 tells a Committer to use) was counted by the only authority on whether a vote counted.
@@ -484,8 +485,8 @@ def distinct_cycle_ids(body: str) -> list[str]:
 #
 # The rule's other half. "3 consecutive ✅ from different cycles" says nothing about
 # *who may cast one*, and the clause that carries it — a cycle does not vote on a PR
-# whose head it pushed, nor on the head pushed by the cycle immediately before it —
-# is refused at post time by `cast-vote.py` (issue #1408). This is the reading side
+# whose head it pushed, inside that cycle's own run — is refused at post time by
+# `cast-vote.py` (issue #1408). This is the reading side
 # of the same clause, which was missing: the count is what a cycle reads when it
 # decides to merge, so a vote that must not have been cast has to read as uncounted.
 # Both halves ask one question — "were the head and the vote cast by the same
@@ -502,11 +503,11 @@ def distinct_cycle_ids(body: str) -> list[str]:
 
 # ── whose window is it? ─────────────────────────────────────────────────────
 #
-# The clause above is a **self**-review guard, and its own premise says so: "a cycle
-# does not vote on a head it pushed, and on the head pushed by the cycle immediately
-# before it, because every cycle on a host is the same instance running again". The
-# cycles of a host are the records on that host — so the question can be asked only
-# of a vote cast by the instance those records belong to.
+# The clause above is a **self**-review guard, and its own premise says so: a cycle
+# does not vote on a head it pushed, because no cycle can judge the head it has just
+# built. The window the clause reads is that cycle's own run, and the records such a
+# run is read from are the records of the host that ran the cycle — so the question
+# can be asked only of a vote cast by the instance those records belong to.
 #
 # Asked of every vote it is not merely wider than the rule: it is a verdict read off
 # the wrong corpus. Measured 2026-10-05 on #1851, the repo's only open PR: two ✅
diff --git a/scripts/review-queue.py b/scripts/review-queue.py
index e4b555fb..8c9683aa 100644
--- a/scripts/review-queue.py
+++ b/scripts/review-queue.py
@@ -998,8 +998,9 @@ def next_action(reading: Reading, cycle: str | None = None, repo: str = REPO,
       2026-09-24T14:46:10);
     * then a merge state that withholds the merge (draft, blocked, behind) — again
       not a review problem, and not curable by a vote;
-    * **then the abstention** (issue #1408): a head pushed by this cycle or by the one
-      immediately before it is not one this cycle may vote on or merge. It sits
+    * **then the abstention** (issue #1408): a head pushed inside this cycle's own run
+      — its own start to the start of the cycle that follows it — is not one this cycle
+      may vote on or merge. It sits
       directly above the two branches that *spend* something, because every branch
       above it asks "what does this PR need?" — and a head one pushed may still need
       a fix push, a conflict resolved, or CI to finish, which is work for the pusher
diff --git a/tests/test_check_merge_freshness.py b/tests/test_check_merge_freshness.py
index 2d0e5484..bcac612e 100644
--- a/tests/test_check_merge_freshness.py
+++ b/tests/test_check_merge_freshness.py
@@ -596,7 +596,7 @@ def test_a_stale_branch_with_no_votes_is_told_the_refresh_is_free(mod, monkeypat
     # (`check-merge-plan-suite.py`, which measures the landing tree without moving the
     # head) and the window fact that makes it the alternative.
     assert "not nothing to *lose*" in remedy, err
-    assert "the cycle after next" in remedy, err
+    assert "the cycle after this one" in remedy, err
     assert "check-merge-plan-suite.py <PR>" in remedy, err
     # The other direction of the channel rule: with no vote at risk there is
     # nothing to vote on, so the remedy line must name no channel at all. Asserted
diff --git a/tests/test_check_vote_count.py b/tests/test_check_vote_count.py
index 054cb94d..fb1afa47 100644
--- a/tests/test_check_vote_count.py
+++ b/tests/test_check_vote_count.py
@@ -117,15 +117,11 @@ def _pinned_cycle_records(mod, tmp_path, monkeypatch):
     the reading host's time zone — a verdict that is green here and red anywhere else,
     which is the defect class this whole family of guards exists to catch. An empty
     directory narrows the window to the *voting cycle's own start*: a fact of the
-    fixture, not of the host. A test that wants the wider window writes the previous
-    cycle's record into a directory it names (`--cycles-log`). The environment override
-    is cleared for the same reason — it would otherwise reach the reading too.
+    fixture, not of the host. A test that needs a *later* cycle's record — the window's
+    far bound — writes it into a directory it names (`--cycles-log`). The environment
+    override is cleared for the same reason — it would otherwise reach the reading too.
     """
     monkeypatch.delenv("EMRG_CYCLES_LOG", raising=False)
-    # The dispatch corpus is the window's other half and has its own override, honoured
-    # ahead of the records' sibling: left set on a host that names one, every test below
-    # would resolve its boundary from that corpus instead of the one it wrote.
-    monkeypatch.delenv("EMRG_SESSIONS_DIR", raising=False)
     empty = tmp_path / "no-cycle-records"
     empty.mkdir()
     monkeypatch.setattr(mod.review_queue(), "DEFAULT_CYCLES_LOGS", (empty,))
@@ -2076,8 +2072,8 @@ def test_the_default_budget_asks_exactly_once(mod, monkeypatch, capsys):
 # --- who may cast a vote: the head's own window ----------------------------
 #
 # The clause `cast-vote.py` refuses to **post** on, read on the counting side (issue
-# #1408: "a cycle abstains on a head it pushed, and on the head pushed by the cycle
-# immediately before it"). The counter is the only instrument a cycle consults before
+# #1408: "a cycle abstains on a head it pushed", read against that cycle's own run).
+# The counter is the only instrument a cycle consults before
 # merging, so a vote that must not have been cast has to read as not counting - and a
 # vote posted straight with `gh pr review` (the form the template tells a Committer to
 # use) never passes the poster's refusal at all.