@@ -334,14 +334,20 @@ changeProbe:
   - When two observations disagree, the newer wins. A render's instant is when it read the origin
     (store time less its longest render), so a render claimed before a re-slug can't undo the probe
     that saw it.
-  - An unchanged observation writes nothing.
-  - A canonical under another entity's prefix is ignored.
+  - An unchanged observation writes nothing, and neither does the same canonical spelled otherwise
+    (`%27` for an apostrophe). That is one document, as the probe's own `path` comparator already
+    treats it.
+  - A canonical under another entity's prefix is ignored, and so is a relative path (only an absolute
+    URL or a `/`-rooted path counts).
 - **Adoption.** When the probe reports a canonical that is another URL of the same entity, and no target
   holds it in rotation, its target is filed due now and urgent, as redirect adoption does.
   - A target suppressed as a canonical verdict (`canonical-mismatch`, `canonical-variant`) is reactivated
     the same way. One suppressed for any other reason (a 404, a noindex) is left alone.
-  - Bounded by `maxPerPass` per pass and node, by `retryAfter` per entity (a canonical that did not take is
-    filed once per window, not nightly), and by both dry runs.
+  - Bounded by `maxPerPass` per pass and node (a resumed pass shares its cap), by `retryAfter` per entity
+    (a canonical that did not take is filed once per window, not nightly, so it costs one render a week for
+    as long as the endpoint names it), and by both dry runs. A pass run as a dry run, including an
+    operator's measure-only sweep, files nothing.
+  - In a dry run, what arming would file is `would-adopt` plus `capped`.
 - **Why.** Measured on one deployment, products re-slug ~100 times a day and the product sitemap
   changes once a day. An out-of-stock product is not in the sitemap at all, so its new canonical
   arrived only by traffic discovery, with its first render jittered across the route's 96h interval.
 
@@ -1534,7 +1534,8 @@ export const configSchema = group('Prerender plugin configuration.', {
 					'rule that maps `canonical` in `pageCheck.fields` (an endpoint field holding the canonical path or URL, ' +
 					'e.g. `{ slot: 6, fact: canonical, compare: path }`). Every probe of a URL on a route with an ' +
 					'`entityPrefix` records the canonical the endpoint names for its entity. When that is ANOTHER URL of ' +
-					'the same entity and no target holds it in rotation, its target is filed due now and urgent, as ' +
+					'the same entity and no target holds it in rotation (in any spelling: `%27` and an apostrophe are one ' +
+					'document), its target is filed due now and urgent, as ' +
 					'redirect adoption does — a target suppressed as a canonical verdict (`canonical-mismatch`, ' +
 					'`canonical-variant`) is reactivated the same way; one suppressed for any other reason is left alone.\n\n' +
 					'WHY: a product whose slug changes while it is out of stock is not in the sitemap, so its new ' +
@@ -1552,13 +1553,16 @@ export const configSchema = group('Prerender plugin configuration.', {
 					dryRun: option(
 						true,
 						'Count `would-adopt` and file nothing. The default, because the number to know first is how many ' +
-							'canonicals a pass would file. The probe\u2019s own `dryRun` files nothing either.'
+							'canonicals a pass would file: `would-adopt` plus `capped` (the cap counts would-adopts too). A ' +
+							'pass run as a dry run — the probe\u2019s own `dryRun`, or an operator\u2019s measure-only sweep — ' +
+							'files nothing either.'
 					),
 					maxPerPass: option(
 						500,
-						'Most targets one pass files on this node. Measured on one deployment, products re-slug ~100 ' +
-							'times a day cluster-wide; a site-wide re-spelling would file every product at once, so past ' +
-							'this the pass counts `capped` and leaves the rest to the sitemap and the next pass.',
+						'Most targets one pass files on this node, counted across the pass\u2019s resumes. Measured on one ' +
+							'deployment, products re-slug ~100 times a day cluster-wide; a site-wide re-spelling would file ' +
+							'every product at once, so past this the pass counts `capped` and leaves the rest to the sitemap ' +
+							'and the next pass.',
 						{ min: 0 }
 					),
 					retryAfter: option(
 
@@ -458,14 +458,15 @@ async function syncQueueState(force = false, pending = null) {
 	return { status, ...desired };
 }
 
-// The longest render among a result's stored variants (ms), 0 when none says: how long before the store
-// the origin was read, at the latest.
-const longestRenderMs = (variants) => {
-	let longest = 0;
+// How long before the store a result's origin read began, at the earliest that can be told: the devices of a
+// job render IN TURN on one slot, so the first device's read began the sum of the stored renders before the
+// store. 0 when none says.
+const renderSpanMs = (variants) => {
+	let span = 0;
 	for (const variant of variants) {
-		if (typeof variant.renderTime === 'number' && variant.renderTime > longest) longest = variant.renderTime;
+		if (typeof variant.renderTime === 'number' && variant.renderTime > 0) span += variant.renderTime;
 	}
-	return longest;
+	return span;
 };
 
 export class RenderQueue extends Resource {
@@ -1071,10 +1072,10 @@ export class RenderQueue extends Resource {
 					complete: everyDevice,
 				}),
 				// The entity registry (util/entity.js): the canonical this page declared, observed when the origin
-				// was READ — the store time less the longest render — so a render claimed before a re-slug cannot
-				// outrank the probe that saw it. A point read, and a write only when the canonical moves; never
-				// rejects.
-				observeRenderedCanonical(scheduleUrl, describing.pageFacts, cachedAt - longestRenderMs(stored)).catch(() => {}),
+				// was READ — the store time less the stored renders, which run one after another — so a render
+				// claimed before a re-slug cannot outrank the probe that saw it. A point read, and a write only
+				// when the canonical moves; never rejects.
+				observeRenderedCanonical(scheduleUrl, describing.pageFacts, cachedAt - renderSpanMs(stored)).catch(() => {}),
 				...observed.map((variant) =>
 					recordReadinessExpectation({ url: scheduleUrl, deviceType: variant.deviceType }, variant.readiness)
 				),
 
@@ -7,7 +7,8 @@
 #
 #   render_schedule  RenderSchedule                  — the hot render queue (isolated)
 #   render_service   Target, QueueStatus,            — URL registry (incl. indexability
-#                    QueueControl                      verdicts) + queue status + pause intent
+#                    QueueControl, Entity              verdicts) + queue status + pause intent
+#                                                      + each entity's current canonical
 #   config           ConfigOverride                  — operator-set config overrides (isolated
 #                                                      because it is SUBSCRIBED; see the type)
 #   page_cache       PrerenderedPage                 — rendered-HTML cache (blob writes)
@@ -166,8 +167,9 @@ type Entity @table(database: "render_service") {
 	canonical: String
 	# Which observer named it: 'probe' or 'render'.
 	canonicalFrom: String
-	# When that observer READ the origin. A later observation that disagrees moves the canonical; an earlier
-	# one (a render claimed before a re-slug, landing after the probe saw it) does not.
+	# When that observer READ the origin — when the CURRENT canonical was first observed; an unchanged
+	# observation writes nothing. A later observation that disagrees moves the canonical; an earlier one (a
+	# render claimed before a re-slug, landing after the probe saw it) does not.
 	canonicalAt: Date
 	firstSeenAt: Date
 	# The last canonical the change probe ADOPTED a target for, and when: a canonical that did not take is
 
@@ -2538,8 +2538,9 @@ export const runProbeSweepOnce = async ({
 			readCheck: config.changeProbe.serveCheck?.enabled ? readPageCheck : null,
 			skipCheckedSince: serveChecksArmed() ? (resume?.originStartedAt ?? startedAt) : null,
 			recordCheck: config.changeProbe.serveCheck?.enabled ? writePageCheck : null,
-			// One observer per pass: it counts this pass's adoptions against `adoptCanonical.maxPerPass`.
-			onCanonical: entitiesOn() ? createCanonicalObserver() : null,
+			// One observer per pass, counting adoptions by the pass's origin (a resume shares its cap), and
+			// filing nothing when THIS pass is a dry run — an operator's measure-only sweep included.
+			onCanonical: entitiesOn() ? createCanonicalObserver({ probeDryRun: limits.dryRun, passId: passOrigin }) : null,
 			guard: theMappingGuard(),
 			...limits,
 			// Rows this pass (or the pass it resumes) already probed — see `processOne`. The same for a