@@ -80,8 +80,9 @@ To add a starter stack (one pick per need for a kind of game), follow [`stacks/R
 - [ ] Tool entries distinguish **software license** from **exported asset** ownership
 
 Verification ages. On the first of each month a workflow opens a "Re-verify batch" issue
-listing the live entries whose licence was read longest ago (over 150 days, about a tenth
-of the catalog). Each item is a self-contained re-read: open the source, confirm the
+listing the live entries whose licence was read longest ago: as many as keep every entry
+inside the 180-day fresh window until the next batch, about a fifth of the catalog a
+month. Each item is a self-contained re-read: open the source, confirm the
 terms, bump `verified` and add a dated Evidence quote, or set `needs-review` and say what
 changed. Those issues carry `good first issue`; pick one if you want a first contribution
 with no code.
 
@@ -36,6 +36,7 @@ missing entry, so freshness and accuracy come before volume.
   (`feed.xml`) and one of re-verified licences (`reverified.xml`); see [docs/data.md](docs/data.md).
 - Monthly dataset releases tagged `vYYYY.MM.DD`, with the version written into `CITATION.cff`.
 - Re-verification in regular batches: since 2026-10 the `reverify.yml` workflow opens a
-  monthly checklist of the entries checked longest ago (over 150 days, about a tenth of the
-  catalog each month), so the July 2026 verifications do not all expire together in mid-2027.
+  monthly checklist of the entries checked longest ago, sized so none passes 180 days before
+  the next batch (about a fifth of the catalog a month, more while the July-September 2026
+  verifications come due); a 24-month simulation in `site/lib/lib.test.mjs` holds it to that.
 - `camera_perspective` and `grid_dimensions` on 2D entries.
@@ -980,11 +980,46 @@ import { batchIssueMarkdown, pickBatch } from "./reverify.mjs";
   eq("batch: a fresh entry is left alone", picked.some((e) => e.id === "fresh"), false);
   eq("batch: deprecated entries are never picked", picked.some((e) => e.id === "gone"), false);
   eq("batch: 150 days is not yet due", picked.some((e) => e.id === "edge"), false);
-  eq("batch: size defaults to a tenth of the live catalog, at least one", pickBatch(pool, { now: rvNow }).length, 1);
+  eq("batch: by default, everything that would turn stale before the next batch", pickBatch(pool, { now: rvNow }).map((e) => e.id).join(","), "undated,june,due,edge");
   eq("batch: nothing due means an empty batch", pickBatch(pool, { now: Date.parse("2026-08-01T00:00:00Z"), size: 10 }).map((e) => e.id).join(","), "undated");
   eq("batch: explicit size caps the list", pickBatch(pool, { now: rvNow, size: 2 }).map((e) => e.id).join(","), "undated,june");
-  const big = Array.from({ length: 100 }, (_, i) => rv(`e${String(i).padStart(3, "0")}`, "2026-01-01"));
-  eq("batch: a tenth of 100 live entries is 10", pickBatch(big, { now: rvNow }).length, 10);
+  // 100 entries read the same day, 109 days ago: they must all be re-read
+  // within two more batches, so the load is spread over the three.
+  const bulge = Array.from({ length: 100 }, (_, i) => rv(`e${String(i).padStart(3, "0")}`, "2026-07-15"));
+  eq("batch: a bulge is spread over the batches before it expires", pickBatch(bulge, { now: rvNow }).length, 34);
+  eq("batch: a bulge is picked oldest first even before it is due", pickBatch(bulge, { now: rvNow })[0].age, 109);
+
+  // The catalog's own verified dates, run through 24 monthly batches in
+  // which every picked entry is re-read on the day: nothing may pass the
+  // fresh window, and no batch may need more than the size it was given.
+  const { listEntryFiles } = await import("./entry-files.mjs");
+  const { parseFrontmatter } = await import("./frontmatter.mjs");
+  const { VERIFIED_FRESH_DAYS } = await import("./shared.mjs");
+  const catalogDir = new URL("../../catalog/", import.meta.url);
+  const { fileURLToPath } = await import("node:url");
+  let sim = listEntryFiles(fileURLToPath(catalogDir))
+    .map((f) => parseFrontmatter(nodeFs.readFileSync(f, "utf8"))?.meta)
+    .filter((m) => m?.id)
+    .map((m) => ({ id: String(m.id), verified: m.verified ? String(m.verified) : null, status: String(m.status || "needs-review") }));
+  const first = new Date();
+  let t = Date.UTC(first.getUTCFullYear(), first.getUTCMonth() + 1, 1, 8);
+  let worstAge = 0;
+  let biggest = 0;
+  for (let m = 0; m < 24; m += 1) {
+    for (const e of sim) {
+      if (e.status === "deprecated" || !e.verified) continue;
+      worstAge = Math.max(worstAge, Math.floor((t - Date.parse(`${e.verified}T00:00:00Z`)) / 86400000));
+    }
+    const picked = new Set(pickBatch(sim, { now: t }).map((e) => e.id));
+    biggest = Math.max(biggest, picked.size);
+    const day = new Date(t).toISOString().slice(0, 10);
+    sim = sim.map((e) => (picked.has(e.id) ? { ...e, verified: day } : e));
+    const d = new Date(t);
+    t = Date.UTC(d.getUTCFullYear(), d.getUTCMonth() + 1, 1, 8);
+  }
+  eq("batch simulation: runs on the real catalog", sim.length > 100, true);
+  eq("batch simulation: no live entry passes the fresh window in 24 months", worstAge <= VERIFIED_FRESH_DAYS, true);
+  eq("batch simulation: a batch stays under a third of the catalog", biggest <= Math.ceil(sim.length / 3), true);
   const md = batchIssueMarkdown({ batch: pickBatch(pool, { now: rvNow, size: 2 }), repo: "https://github.com/o/r", date: "2026-11-01", total: 6 });
   has("batch issue links the entry file", md, "[`june`](https://github.com/o/r/blob/main/catalog/2d/june.md)");
   has("batch issue says what was recorded", md, "recorded as `CC0`, needs-review, verified 2026-06-01 (153 days ago)");
 
@@ -12,8 +12,6 @@ import { VERIFIED_FRESH_DAYS } from "./shared.mjs";
  * fresh to aging.
  */
 export const DUE_DAYS = VERIFIED_FRESH_DAYS - 30;
-/** Months the whole catalog should take to cycle through the batches. */
-export const CYCLE_MONTHS = 10;
 
 /** Days since `verified` at `now`, or null when the date is unusable. */
 function ageDays(verified, now) {
@@ -22,27 +20,70 @@ function ageDays(verified, now) {
 }
 
 /**
- * The entries due for a re-read: active or needs-review, last checked more
- * than `dueDays` ago or never, oldest first. `size` defaults to a tenth of
- * the live catalog so every entry comes round in about CYCLE_MONTHS.
+ * Days between two batches, at most: the workflow runs on the 1st of each
+ * month, and the longest month has 31 days.
+ */
+export const BATCH_GAP_DAYS = 31;
+
+/**
+ * Batch `k` (0 = this one) is the last that can re-read an entry before
+ * its licence check turns VERIFIED_FRESH_DAYS old; undated entries are due
+ * now. Negative (already late) counts as 0.
+ */
+function deadlineBatch(age) {
+  if (age === null) return 0;
+  return Math.max(0, Math.floor((VERIFIED_FRESH_DAYS - age) / BATCH_GAP_DAYS));
+}
+
+/**
+ * The smallest steady batch size that re-reads every live entry before it
+ * turns VERIFIED_FRESH_DAYS old: for each coming batch k, the entries whose
+ * deadline is batch k or sooner, spread over the k + 1 batches left. A bulge
+ * of entries read in the same week is spread over the months before it
+ * expires instead of landing in one batch. The look-ahead stops where an
+ * entry re-read now would itself fall due.
+ */
+export function batchSizeNeeded(ages) {
+  const horizon = Math.floor(VERIFIED_FRESH_DAYS / BATCH_GAP_DAYS);
+  const byBatch = new Array(horizon + 1).fill(0);
+  for (const age of ages) {
+    const k = deadlineBatch(age);
+    if (k <= horizon) byBatch[k] += 1;
+  }
+  let need = 0;
+  let cumulative = 0;
+  for (let k = 0; k <= horizon; k += 1) {
+    cumulative += byBatch[k];
+    need = Math.max(need, Math.ceil(cumulative / (k + 1)));
+  }
+  return need;
+}
+
+/**
+ * This month's batch, oldest first (undated first of all), sized by
+ * batchSizeNeeded so no live entry passes VERIFIED_FRESH_DAYS before a batch
+ * reaches it. Every entry more than `dueDays` old is in it, since it would
+ * turn stale before the next one. An explicit `size` takes that many of the
+ * entries more than `dueDays` old instead.
  */
 export function pickBatch(entries, { now = Date.now(), dueDays = DUE_DAYS, size } = {}) {
-  const live = entries.filter((e) => e.status !== "deprecated");
-  const limit = size ?? Math.ceil(live.length / CYCLE_MONTHS);
-  return live
+  const live = entries
+    .filter((e) => e.status !== "deprecated")
     .map((entry) => ({ entry, age: entry.verified ? ageDays(entry.verified, now) : null }))
-    .filter((r) => r.age === null || r.age > dueDays)
-    .sort((a, b) => (b.age ?? Infinity) - (a.age ?? Infinity) || a.entry.id.localeCompare(b.entry.id))
-    .slice(0, limit)
-    .map((r) => ({ ...r.entry, age: r.age }));
+    .sort((a, b) => (b.age ?? Infinity) - (a.age ?? Infinity) || a.entry.id.localeCompare(b.entry.id));
+  const picked =
+    size === undefined
+      ? live.slice(0, batchSizeNeeded(live.map((r) => r.age)))
+      : live.filter((r) => r.age === null || r.age > dueDays).slice(0, size);
+  return picked.map((r) => ({ ...r.entry, age: r.age }));
 }
 
 const code = (s) => `\`${String(s).replaceAll("`", "%60")}\``;
 
 /** The issue body: how to do one, then a checklist with what to re-read. */
 export function batchIssueMarkdown({ batch, repo, date, total, dueDays = DUE_DAYS }) {
   const lines = [
-    `Monthly re-verification batch, ${date}: the ${batch.length} entries whose licence was read longest ago (more than ${dueDays} days, out of ${total} live entries). Each one is a small, self-contained check, and a good first contribution.`,
+    `Monthly re-verification batch, ${date}: the ${batch.length} entries whose licence was read longest ago, out of ${total} live entries: enough that none passes ${VERIFIED_FRESH_DAYS} days before the next batch. Each one is a small, self-contained check, and a good first contribution.`,
     "",
     "**How to do one**",
     "1. Open the entry and its source page (the `url` in the frontmatter).",
 
@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 /**
  * Writes the monthly "re-verify batch" issue: the live entries whose licence
- * was read longest ago (more than 150 days), oldest first, sized so the
- * catalog cycles in about ten months.
+ * was read longest ago, oldest first, as many as keep every entry inside the
+ * 180-day fresh window (lib/reverify.mjs batchSizeNeeded).
  *   node site/reverify-batch.mjs [--report <file.md>] [--size <n>]
  * Under GitHub Actions it also writes `count=<n>` to $GITHUB_OUTPUT.
  */