The window worker: group leases, the stream serving the corpus, the snapshot through the API (design 1 and 5)

A worker thread leases a group and takes its ranges in article order through
one carried window; the coordinator keeps one cursor a group (group_leases,
migration 6500) and hands out the next range, the rules and nothing about
where the chunks are: the range stream serves a stored range's chunks from the
corpus file and a live one's from the spool. The window's snapshot (bincode:
the frontier, the open files, releases and albums, the upload numbers, the
batch-counter table) goes to the coordinator every EDGE_SNAPSHOT_MINUTES and
when the group is given back, and the next holder restores it; a takeover
after LEASE_TTL_SECONDS plans the ranges from the snapshot's article again.
The prefetcher runs ahead of held groups' cursors and skips chunks the corpus
has. LEASE_MIN_PRIORITY..LEASE_MAX_PRIORITY bound what is leased. edge-node
holds groups by default; --ranges keeps the old per-range path.

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

app/services/prefetcher.ts

@@ -425,10 +425,18 @@ export class Prefetcher {
       )
     // Leased ranges, checked against the spool's files whatever spooled_at says: a worker waits for them.
     const leased = await rows(db.query()).where('r.status', 'leased').orderBy('r.leased_at')
+    // The groups workers hold (group_leases; REBUILD.md design 1): the prefetcher runs ahead of their cursors.
+    const held: number[] = (
+      await db
+        .from('group_leases')
+        .whereNotNull('node_id')
+        .where('heartbeat_at', '>=', new Date(Date.now() - coordinatorConfig.leaseTtlSeconds * 1000))
+        .select('group_id')
+    ).map((l) => Number(l.group_id))
     // Planned ranges ahead: those started already, then new ones up to SPOOL_AHEAD_PER_LEASE per lease.
     const ahead = Math.max(
       coordinatorConfig.spool.minAhead,
-      coordinatorConfig.spool.aheadPerLease * leased.length
+      coordinatorConfig.spool.aheadPerLease * Math.max(leased.length, held.length)
     )
     const started = await rows(db.query())
       .where('r.status', 'planned')
@@ -448,14 +456,17 @@ export class Prefetcher {
     const want = Math.max(ahead - Number(ready), short)
     // The catalog at its cap on the NVMe: no history fetched ahead (CatalogSpace).
     const full = await CatalogSpace.full()
+    // Ahead of each held group's cursor: its next ranges in article order, a range of every held group before any
+    // group's second; without held groups (no window worker running) nothing is fetched ahead for workers.
     const fresh =
-      room && want > 0
+      room && want > 0 && held.length > 0
         ? await rows(db.query())
             .where('r.status', 'planned')
             .where('r.spooled_chunks', 0)
             .whereRaw('r.next_id <= r.end_id')
+            .whereIn('r.group_id', held)
             .where((q: any) => (full ? q.where('r.priority', '<', 0) : q))
-            .orderBy([{ column: 'r.priority' }, { column: 'r.id' }])
+            .orderByRaw('row_number() OVER (PARTITION BY r.group_id ORDER BY r.start_id), r.priority, r.start_id')
             .limit(want)
         : []
     const targets: Target[] = []
@@ -464,9 +475,12 @@ export class Prefetcher {
       const end = Number(row.end_id)
       const total = Spool.chunksOf({ start, end }).length
       const missing: ChunkSpan[] = []
+      // A chunk already in the corpus isn't spooled: the stream serves it from there (REBUILD.md design 1).
+      const corpusRange = row.capture === true ? { group: row.group as string, start, end } : null
       for (const span of Spool.chunksOf({ start, end }, Number(row.next_id))) {
-        if (!this.claimed.has(`${row.id}:${span.from}`) && !(await Spool.has(Number(row.id), span)))
-          missing.push(span)
+        if (this.claimed.has(`${row.id}:${span.from}`) || (await Spool.has(Number(row.id), span))) continue
+        if (corpusRange && (await Corpus.has(corpusRange, span))) continue
+        missing.push(span)
       }
       if (missing.length > 0) {
         targets.push({