Twins by content: at most 500 twins read per pair

With the hash typed as the column (f537add) the planner walks every twin of a
pair by index; 55 pairs have over 500 twins, up to 131k, and a flush with such
a pair ran the query for 37 s inside its transaction, the other flushes and
node-api's class counters waiting on it. A LATERAL per pair now reads its
lowest 500 release ids and takes the first named one: 49 ms for 305 pairs with
the five hottest among them. LOG.md (138).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

REBUILD.md

@@ -717,10 +717,13 @@ releases; the inspector matches them again), `nntp_shares`, `nodes`,
 - Gone: `fragments`, `range_blocks`, `release_final()` (final = finished:
   `settled_at IS NOT NULL`), the settler, the fragment merger,
   `releases_category_newest_idx`.
-- `release_inspections` and `probe_candidates` on `CHUNK_TABLESPACE` (the
-  HDD) with their indexes. Note LOG.md 2026-10-19 (81): the judge's fake
-  rule read all of `release_inspections` every round, 17 min on the HDD;
-  the judge must read it by release or keep what it needs on the NVMe.
+- `release_inspections` and `probe_candidates` were on `CHUNK_TABLESPACE`
+  (the HDD) with their indexes; both are back on the NVMe (migrations 4800
+  and 7300). Note LOG.md 2026-10-19 (81): the judge's fake rule read all of
+  `release_inspections` every round, 17 min on the HDD; and 2026-11-03
+  (136): the prober's catalog claim updates `probe_candidates` from random
+  points every minute, 2–3 min on the HDD beside the pending ladder's sweep.
+  What a worker reads or updates by random key every minute stays on the NVMe.
 
 ### Batch store (built 2026-10-25)
 
@@ -947,9 +950,12 @@ f. **Nothing enters the catalog without a usable name** (amended
    climb, each by an index (`pending_releases_signature_idx` for a
    poster's rows: tested on the rows, a signature was a scan of the whole
    table; LOG.md (133), (134)). The batch store, the record, the claim
-   and the sweep lock pending rows in one order (`lockOrder`), and a
-   flush that deadlocks anyway keeps its outcomes for the next (LOG.md
-   (134)). The namer
+   and the sweep lock pending rows in one order, by key and the counters
+   after (`lockOrder` for the multi-row statements; the record and the
+   sweep lock their rows with `SELECT … ORDER BY release_key FOR UPDATE`
+   first, since an UPDATE's join or `= ANY(subquery)` locks in plan
+   order), and a flush that deadlocks anyway keeps its outcomes for the
+   next (LOG.md (134), (137)). The namer
    (`app/services/pending_namer.ts`, in the prober's process): a named
    release's article span read again from the corpus (the stored range's
    chunks) or by XOVER on a connection of its own, a chunk of articles

app/services/hash_twins.ts

@@ -5,20 +5,29 @@ import db from '@adonisjs/lucid/services/db'
  * repeated verdict match) in a catalog release that has a name, readable or found inside. The same film posted
  * under scrambles by other tools gets that name without another fetch. Releases with a junk verdict don't count.
  */
+/** Twins read per pair: the hottest pairs have 131k. */
+const TWIN_SCAN = 500
+
 export async function twinNames(
   pairs: { hash16k: string; size: number }[],
   trx: { rawQuery: typeof db.rawQuery } = db
 ): Promise<Map<string, string>> {
   const out = new Map<string, string>()
   if (pairs.length === 0) return out
+  // Per pair the first named twin among its lowest TWIN_SCAN release ids. hash16k is typed as the column
+  // (char(32)): as text the join cast the column and scanned all of file_hashes, 4 s a call; and with the index
+  // the hottest pairs (55 with over 500 twins, up to 131k, all readable) made a call walk every twin, 37 s inside
+  // the flush's transaction (LOG.md (138)). One name is all a pair needs.
   const { rows } = await trx.rawQuery(
-    `SELECT DISTINCT ON (h.hash16k, h.size) h.hash16k, h.size, coalesce(r.inner_name, r.name) AS name
-     FROM jsonb_to_recordset(?::jsonb) AS v(hash16k text, size bigint)
-     JOIN file_hashes h ON h.hash16k = v.hash16k AND h.size = v.size
-     JOIN releases r ON r.id = h.release_id AND (r.readable OR r.inner_name IS NOT NULL)
-     WHERE NOT EXISTS (SELECT 1 FROM release_verdicts x WHERE x.release_id = r.id)
-     ORDER BY h.hash16k, h.size, r.readable DESC, r.id`,
-    [JSON.stringify(pairs)]
+    `SELECT v.hash16k, v.size, t.name
+     FROM jsonb_to_recordset(?::jsonb) AS v(hash16k char(32), size bigint)
+     CROSS JOIN LATERAL (
+       SELECT coalesce(r.inner_name, r.name) AS name
+       FROM (SELECT release_id FROM file_hashes h WHERE h.hash16k = v.hash16k AND h.size = v.size ORDER BY release_id LIMIT ?) h
+       JOIN releases r ON r.id = h.release_id AND (r.readable OR r.inner_name IS NOT NULL)
+       WHERE NOT EXISTS (SELECT 1 FROM release_verdicts x WHERE x.release_id = r.id)
+       ORDER BY r.readable DESC, r.id LIMIT 1) t`,
+    [JSON.stringify(pairs), TWIN_SCAN]
   )
   for (const r of rows) out.set(`${r.hash16k}\t${r.size}`, r.name)
   return out

app/services/pending_ladder.ts

@@ -289,6 +289,12 @@ class PendingLadder {
         final: null,
       }
     })
+    // The rows locked in key order first: the UPDATE's join below takes them in whatever order the plan does.
+    await trx.rawQuery(
+      `SELECT 1 FROM pending_releases WHERE release_key = ANY(SELECT decode(k, 'hex') FROM unnest(?::text[]) AS k)
+       ORDER BY release_key FOR UPDATE`,
+      [rows.map((r) => r.release_key).sort()]
+    )
     await trx.rawQuery(
       `UPDATE pending_releases p SET status = v.status, tries = v.tries, named = coalesce(v.named, p.named),
          inspections = CASE WHEN v.inspection IS NULL THEN p.inspections ELSE p.inspections || v.inspection END,
@@ -470,9 +476,15 @@ class PendingLadder {
       .filter((key: string) => !explored(key, samplePercent))
       .sort()
     if (keys.length === 0) return 0
+    // Locked in key order (the record's lock order, LOG.md (137)): a plain `key = ANY(subquery)` locks in scan
+    // order and deadlocked against a batch upsert; ORDER BY sorts before FOR UPDATE locks.
     const { rows: gone } = await db.rawQuery(
-      `UPDATE pending_releases SET status = ? WHERE status = ? AND release_key = ANY(SELECT decode(k, 'hex') FROM unnest(?::text[]) AS k)
-       RETURNING tool, group_id, klass`,
+      `UPDATE pending_releases p SET status = ?
+       FROM (SELECT release_key FROM pending_releases
+             WHERE status = ? AND release_key = ANY(SELECT decode(k, 'hex') FROM unnest(?::text[]) AS k)
+             ORDER BY release_key FOR UPDATE) k
+       WHERE p.release_key = k.release_key
+       RETURNING p.tool, p.group_id, p.klass`,
       [PENDING.discarded, PENDING.waiting, keys]
     )
     const counts = new Map<string, { tool: string; group_id: number; klass: number; n: number }>()

database/migrations/1770000007400_prober_tables_on_nvme.ts

@@ -0,0 +1,37 @@
+import { BaseSchema } from '@adonisjs/lucid/schema'
+
+/**
+ * Everything the prober reads or writes in the catalog's tablespace (default_tablespace: nvme on homelab), out of
+ * CHUNK_TABLESPACE (the HDD): pending_releases with its two HDD indexes (migration 6300), release_inspections
+ * (6000), probe_cache with its toast. The edge's batch upserts into pending_releases took minutes each on the HDD and
+ * the prober's flushes waited on them (LOG.md 2026-11-03 (137)); and with these on the NVMe the prober can run
+ * through the night without the HDD. Homelab moved them by hand (edge, node-api and the workers stopped; ~66 GB);
+ * a no-op where they're there already, or without a default tablespace (tests).
+ */
+export default class extends BaseSchema {
+  async up() {
+    this.defer(async (db) => {
+      const { rows: setting } = await db.rawQuery(
+        `SELECT current_setting('default_tablespace') AS target`
+      )
+      const target = setting[0].target
+      if (!target) return
+      for (const table of ['pending_releases', 'release_inspections', 'probe_cache']) {
+        const { rows } = await db.rawQuery(
+          `SELECT c.relname, c.relkind FROM pg_class c LEFT JOIN pg_tablespace t ON t.oid = c.reltablespace
+           WHERE (c.relname = ? OR c.oid IN (SELECT indexrelid FROM pg_index WHERE indrelid = ?::regclass))
+             AND c.relkind IN ('r', 'i') AND coalesce(t.spcname, 'pg_default') <> ?
+           ORDER BY c.relkind DESC, c.relname`,
+          [table, table, target]
+        )
+        for (const { relname, relkind } of rows) {
+          await db.rawQuery(
+            `ALTER ${relkind === 'i' ? 'INDEX' : 'TABLE'} ${relname} SET TABLESPACE ${target}`
+          )
+        }
+      }
+    })
+  }
+
+  async down() {}
+}

deploy/deploy.sh

@@ -47,8 +47,9 @@ echo "== recreating app services"
 docker compose stop edge
 if [ -e "$CACHE/paused" ]; then
   # Paused for the night (~/bin/usenet-rebuild-pause.sh): the workers stay stopped, the resume starts the new build.
-  echo "== paused: coordinator, prober, merger, judge, spotter, spot-inspector and edge left stopped"
-  docker compose up -d --no-deps node-api web
+  # The prober runs through the night (2026-11-03, LOG.md (137)), so it gets the new build now.
+  echo "== paused: coordinator, merger, judge, spotter, spot-inspector and edge left stopped"
+  docker compose up -d --no-deps node-api web prober
 else
   docker compose up -d --no-deps node-api web coordinator prober merger judge spotter spot-inspector
   if [ -e "$CACHE/no-edge" ]; then

deploy/usenet-rebuild-pause.sh

@@ -1,12 +1,13 @@
 #!/bin/sh
 # Installed as ~/bin/usenet-rebuild-pause.sh (by hand). Nightly (homelab crontab, 23:45): voyager 2's processing paused for the night; usenet-rebuild-resume.sh (07:45)
-# starts it again. Postgres, web and node-api stay up. Takes the deploy lock, so it never runs during a CI deploy, and
-# leaves .cache/paused, so a deploy in the night doesn't start the workers again.
+# starts it again. Postgres, web, node-api and the prober stay up: since 2026-11-03 (LOG.md (137)) everything the
+# prober touches is on the NVMe, so it probes through the night without the HDD. Takes the deploy lock, so it never
+# runs during a CI deploy, and leaves .cache/paused, so a deploy in the night doesn't start the workers again.
 cd /mnt/bulk/usenet-rebuild || exit 1
 exec 9>.cache/deploy.lock
 flock 9
 touch .cache/paused
 date "+%F %T pausing"
 docker compose stop edge
-docker compose stop coordinator prober merger judge spotter spot-inspector
+docker compose stop coordinator merger judge spotter spot-inspector
 docker compose ps --format "{{.Service}} {{.Status}}"