An "ancient" range a group: articles 1 … low watermark − 1, never filled

Every group is tiled from article 1 now: one range with status 'ancient'
covers what had expired on the server before the group was planned.
Nothing selects it (leases, prefetcher, corpus fill, tail merger all take
'planned'), the status panel reports it apart, the search's history stats
leave it out. Migration 6700 adds it for the groups planned before;
Planner.historyRows (now a pure function, unit-tested) for new groups.
The status bands are ordered by an explicit key: the ancient row at
priority 0 tied "history 0-999" with "window 0".

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

app/services/planner.ts

@@ -35,20 +35,8 @@ class Planner {
 
   async planGroup(group: { id: number; name: string }): Promise<number> {
     const info = await NntpPool.use((client) => client.group(group.name))
-    const size = coordinatorConfig.rangeArticles
     const last = await db.from('ranges').where('group_id', group.id).max('end_id as end').first()
-    const from = Math.max(info.low, Number(last?.end ?? 0) + 1)
-    const span = Math.max(1, info.high - info.low)
-    const rows = []
-    for (let start = from; start <= info.high; start += size) {
-      rows.push({
-        group_id: group.id,
-        start_id: start,
-        end_id: Math.min(start + size - 1, info.high),
-        next_id: start,
-        priority: Math.floor((1000 * (start - info.low)) / span),
-      })
-    }
+    const rows = historyRows(group.id, info, Number(last?.end ?? 0), coordinatorConfig.rangeArticles)
     for (let i = 0; i < rows.length; i += 2000) await db.table('ranges').multiInsert(rows.slice(i, i + 2000))
     await db.from('groups').where('id', group.id).update({ low: info.low, high: info.high, planned_at: new Date() })
     return rows.length
@@ -270,4 +258,34 @@ export function tailMerges(
   return merges
 }
 
+/**
+ * The rows a group's history is cut into, from `lastEnd + 1` (0: the group has no ranges yet) up to the high
+ * watermark: RANGE_ARTICLES slices at the position priority. A group planned for the first time also gets one
+ * "ancient" range, articles 1 … low − 1: what had expired on the server before it was planned. Status
+ * 'ancient', never leased or fetched; it keeps the tiling complete from article 1 (migration 6700 added it for
+ * the groups planned before 2026-10-28).
+ */
+export function historyRows(
+  groupId: number,
+  info: { low: number; high: number },
+  lastEnd: number,
+  size: number
+): Record<string, unknown>[] {
+  const rows: Record<string, unknown>[] = []
+  if (lastEnd === 0 && info.low > 1)
+    rows.push({ group_id: groupId, start_id: 1, end_id: info.low - 1, next_id: 1, priority: 0, status: 'ancient' })
+  const from = Math.max(info.low, lastEnd + 1)
+  const span = Math.max(1, info.high - info.low)
+  for (let start = from; start <= info.high; start += size) {
+    rows.push({
+      group_id: groupId,
+      start_id: start,
+      end_id: Math.min(start + size - 1, info.high),
+      next_id: start,
+      priority: Math.floor((1000 * (start - info.low)) / span),
+    })
+  }
+  return rows
+}
+
 export default new Planner()

app/services/search_service.ts

@@ -304,9 +304,9 @@ class SearchService {
     // History by articles; the pass: the history ranges before those deferred behind them (priority
     // 2000 apart; e.g. groups added later that go first).
     const { rows: ranges } = await db.rawQuery(
-      `WITH h AS (SELECT status, priority, end_id - start_id + 1 AS n FROM ranges WHERE priority >= 0),
+      `WITH h AS (SELECT status, priority, end_id - start_id + 1 AS n FROM ranges WHERE priority >= 0 AND status <> 'ancient'),
             pass AS (SELECT (floor(coalesce(min(priority) FILTER (WHERE status <> 'done'), 0) / 2000) + 1) * 2000 AS below FROM h)
-       SELECT (SELECT count(*) FILTER (WHERE status = 'done') FROM ranges) AS done, (SELECT count(*) FROM ranges) AS total,
+       SELECT (SELECT count(*) FILTER (WHERE status = 'done') FROM ranges) AS done, (SELECT count(*) FROM ranges WHERE status <> 'ancient') AS total,
               coalesce(sum(n) FILTER (WHERE status = 'done'), 0) AS history_done, coalesce(sum(n), 0) AS history,
               coalesce(sum(n) FILTER (WHERE status = 'done' AND priority < (SELECT below FROM pass)), 0) AS pass_done,
               coalesce(sum(n) FILTER (WHERE priority < (SELECT below FROM pass)), 0) AS pass,

app/services/status.ts

@@ -54,6 +54,8 @@ export interface Status {
   corpus: { pendingRanges: number; pendingArticles: number }
   spool: { ranges: number; chunks: number }
   tail: { groups: number; ranges: number; articles: number }
+  /** The 'ancient' ranges: articles below the low watermark the groups were planned at (expired, never fetched). */
+  ancient: { groups: number; articles: number }
   held: HeldGroup[]
   snapshots: { count: number; gb: number; oldestHours: number | null; largest: SnapshotFile[] }
   releases: { estimated: number; provisional: number }
@@ -100,8 +102,10 @@ class StatusService {
               count(*) FILTER (WHERE status = 'done') AS done,
               coalesce(sum(end_id - start_id + 1) FILTER (WHERE status = 'done'), 0) AS done_articles,
               count(*) FILTER (WHERE status = 'failed') AS failed
-       FROM ranges GROUP BY 1 ORDER BY min(priority)`,
-      [tail]
+       FROM ranges GROUP BY 1
+       ORDER BY min(CASE WHEN priority <= ? THEN 0 WHEN priority < 0 THEN 1 WHEN capture AND priority <= 2 THEN 2 + priority
+                        WHEN priority < 1000 THEN 10 ELSE 11 + priority / 1000 END)`,
+      [tail, tail]
     )
     const { rows: hour } = await db.rawQuery(
       `SELECT coalesce(sum(end_id - start_id + 1) FILTER (WHERE done_at > now() - interval '1 hour'), 0) AS indexed,
@@ -114,7 +118,9 @@ class StatusService {
               coalesce(sum(spooled_chunks) FILTER (WHERE status IN ('planned', 'leased')), 0) AS spooled_chunks,
               count(DISTINCT group_id) FILTER (WHERE status = 'planned' AND priority <= ?) AS tail_groups,
               count(*) FILTER (WHERE status = 'planned' AND priority <= ?) AS tail_ranges,
-              coalesce(sum(end_id - next_id + 1) FILTER (WHERE status = 'planned' AND priority <= ?), 0) AS tail_articles
+              coalesce(sum(end_id - next_id + 1) FILTER (WHERE status = 'planned' AND priority <= ?), 0) AS tail_articles,
+              count(DISTINCT group_id) FILTER (WHERE status = 'ancient') AS ancient_groups,
+              coalesce(sum(end_id - start_id + 1) FILTER (WHERE status = 'ancient'), 0) AS ancient_articles
        FROM ranges`,
       [tail, tail, tail]
     )
@@ -194,6 +200,7 @@ class StatusService {
         pendingArticles: Number(h.corpus_pending_articles),
       },
       spool: { ranges: Number(h.spooled_ranges), chunks: Number(h.spooled_chunks) },
+      ancient: { groups: Number(h.ancient_groups), articles: Number(h.ancient_articles) },
       tail: {
         groups: Number(h.tail_groups),
         ranges: Number(h.tail_ranges),
@@ -264,7 +271,7 @@ class StatusService {
       `Last hour: ${b(s.lastHour.indexedArticles)} articles indexed in ${n(s.lastHour.doneRanges)} ranges (${n(s.lastHour.indexedArticles / 3600)}/s); corpus fill ${b(s.lastHour.storedArticles)} in ${n(s.lastHour.storedRanges)} ranges, ${n(s.corpus.pendingRanges)} capture ranges (${b(s.corpus.pendingArticles)}) still to store`
     )
     lines.push(
-      `Spool: ${n(s.spool.chunks)} chunks in ${n(s.spool.ranges)} ranges. Tail: ${b(s.tail.articles)} planned in ${n(s.tail.ranges)} ranges of ${n(s.tail.groups)} groups`
+      `Spool: ${n(s.spool.chunks)} chunks in ${n(s.spool.ranges)} ranges. Tail: ${b(s.tail.articles)} planned in ${n(s.tail.ranges)} ranges of ${n(s.tail.groups)} groups. Ancient: ${b(s.ancient.articles)} articles below the low watermark of ${n(s.ancient.groups)} groups`
     )
     lines.push('')
     const table = (header: string[], rows: string[][]) => {