Pending ladder by class, twins by content, dropped classes at the edge

The prober names 6% of the unnamed releases it finishes and the pending
queue (44M) grows eleven times faster than it probes. A sample of 44,530
finished pending rows shows the headers predict a name: size bucket, name
shape, completeness, tool and group separate 0% classes from 95% ones,
while the learner keyed on tool and group alone (LOG.md (130)).

- lib/release/classes.ts, names::pending_class, SQL pending_class():
  a release's class (size × shape × partial, 1..70), the three in step.
- Migration 6800: pending_releases.klass and target_bytes (the first
  target's article; candidates carry bytes now), pending_classes with
  each class's climbs, names, waiting and verdict, the claim's index.
- The ladder claims the classes with the best record first (a prior for
  the unexplored, at most a quarter of a claim from one), the cheapest
  target first within one, then the oldest of the rest; records classes
  like signatures and drops them at the same thresholds; discards their
  waiting releases. Claimed rows sorted in code: an UPDATE returns none.
- The rule set's droppedClasses: the edge keeps unnamed releases of a
  dropped class out of the pending store (counted as garbage), the
  explored sample excepted.
- hash_twins.ts: a probed file whose first 16 KiB and size match a named
  catalog release's names a pending release the probe didn't, and sets
  the inner name of a catalog release without one.
- pending:classes classes the rows from before and seeds the record from
  the finished ones; rules:classes publishes the dropped classes;
  releases:readable also marks the rows' candidates unreadable.

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

app/services/batch_store.ts

@@ -9,6 +9,7 @@ import { SIDECAR } from '#services/sidecar_folder'
 import { identityKey, releaseKey } from '#lib/release/keys'
 import { sourceCode } from '#lib/release/source'
 import { uploadTool } from '#lib/rules/index'
+import { byEffort } from '#services/pending_ladder'
 import { TEXT_KINDS, TEXT_MAX, textsToStore } from '#lib/release/text_kind'
 
 /**
@@ -179,11 +180,14 @@ class BatchStore {
     candidates: ProbeCandidate[]
   ): Promise<number> {
     if (releases.length === 0) return 0
-    const targets = new Map<string, { kind: string; messageId: string; file: string }[]>()
+    const targets = new Map<
+      string,
+      { kind: string; messageId: string; file: string; bytes?: number }[]
+    >()
     for (const c of candidates) {
       const key = slot(c.releaseKey, c.upload ?? 0)
       const list = targets.get(key) ?? []
-      list.push({ kind: c.kind, messageId: c.messageId, file: c.file })
+      list.push({ kind: c.kind, messageId: c.messageId, file: c.file, bytes: c.bytes })
       targets.set(key, list)
     }
     let written = 0
@@ -207,25 +211,46 @@ class BatchStore {
           file_total: r.fileTotal,
           tool: r.tool ?? (probes[0] ? uploadTool(probes[0].messageId) : 'unknown'),
           candidates: probes,
+          // The first target's article (by effort): the cheapest probe first within a class (LOG.md (130)).
+          target_bytes: byEffort(probes)[0]?.bytes ?? null,
         }
       })
       const { rows: done } = await trx.rawQuery(
         `INSERT INTO pending_releases (release_key, identity_key, group_id, name, poster, posted_at, last_posted_at, first_article, last_article,
-                                       files, segments, bytes, partial, finished, file_total, tool, candidates)
+                                       files, segments, bytes, partial, finished, file_total, tool, candidates, klass, target_bytes)
          SELECT decode(v.release_key, 'hex'), decode(v.identity_key, 'hex'), ?, v.name, v.poster, to_timestamp(v.first / 1000.0), to_timestamp(v.last / 1000.0),
-                v.first_article, v.last_article, v.files, v.segments, v.bytes, v.partial, v.finished, v.file_total, v.tool, v.candidates
+                v.first_article, v.last_article, v.files, v.segments, v.bytes, v.partial, v.finished, v.file_total, v.tool, v.candidates,
+                pending_class(v.name, v.bytes, v.partial), v.target_bytes
          FROM jsonb_to_recordset(?::jsonb) AS v(release_key text, identity_key text, name text, poster text, first bigint, last bigint, first_article bigint, last_article bigint,
-                                               files int, segments bigint, bytes bigint, partial boolean, finished boolean, file_total int, tool text, candidates jsonb)
+                                               files int, segments bigint, bytes bigint, partial boolean, finished boolean, file_total int, tool text, candidates jsonb, target_bytes bigint)
          ON CONFLICT (release_key) DO UPDATE SET
            files = pending_releases.files + excluded.files, segments = pending_releases.segments + excluded.segments, bytes = pending_releases.bytes + excluded.bytes,
            last_posted_at = greatest(pending_releases.last_posted_at, excluded.last_posted_at), last_article = greatest(pending_releases.last_article, excluded.last_article),
            partial = excluded.partial, finished = excluded.finished, file_total = coalesce(excluded.file_total, pending_releases.file_total),
-           candidates = CASE WHEN jsonb_array_length(pending_releases.candidates) = 0 THEN excluded.candidates ELSE pending_releases.candidates END
+           candidates = CASE WHEN jsonb_array_length(pending_releases.candidates) = 0 THEN excluded.candidates ELSE pending_releases.candidates END,
+           klass = pending_class(pending_releases.name, pending_releases.bytes + excluded.bytes, excluded.partial),
+           target_bytes = coalesce(pending_releases.target_bytes, excluded.target_bytes)
          WHERE NOT pending_releases.finished
-         RETURNING release_key`,
+         RETURNING release_key, tool, klass, (xmax = 0) AS inserted`,
         [groupId, JSON.stringify(rows)]
       )
       written += done.length
+      // Each class seen gets its row in the ladder's record, so the claim explores it (pending_classes).
+      const classes = new Map<string, { tool: string; klass: number; waiting: number }>()
+      for (const d of done) {
+        const key = `${d.tool}\t${d.klass}`
+        const entry = classes.get(key) ?? { tool: d.tool, klass: Number(d.klass), waiting: 0 }
+        if (d.inserted) entry.waiting++
+        classes.set(key, entry)
+      }
+      if (classes.size > 0) {
+        await trx.rawQuery(
+          `INSERT INTO pending_classes (tool, group_id, klass, waiting)
+           SELECT v.tool, ?, v.klass, v.waiting FROM jsonb_to_recordset(?::jsonb) AS v(tool text, klass int, waiting int)
+           ON CONFLICT (tool, group_id, klass) DO UPDATE SET waiting = pending_classes.waiting + excluded.waiting`,
+          [groupId, JSON.stringify([...classes.values()])]
+        )
+      }
     }
     return written
   }