table

Overview ¶

clear.go: `nova-sprint table clear` (#3637). Zeroes the table's landed column in under a second and leaves waiting untouched: every member of every ws:<s>:landed set moves to done/ok through the one task move (ns_tcard_move, fn/lua/02_card_move.lua, #3778: landed -> done/ok; the card stays, in ws:<s>:done, which the stream table does not print), and each friend's current done count (ZCARD of its done, merging and landed card sets) is stored in ws:done0 (no longer read by the table, #4071). working and merging are live places, not counters, so a clear never moves them.

Round trips: the stream and friend lists, the landed members and done counts, the landed tasks' fields (the checkpoint), then ONE MULTI/EXEC that applies every move. The caller writes the checkpoint before Apply.

live.go: the live layout of nova-sprint table (#2674), a Go port of the bash of record rowan-tools bin/sprint-table-redis. It reads the keys that script reads and prints its layout byte for byte, but for one line:

SPRINT TABLE / the one count / blank / the bench block / two blanks /
the friend block.

The progress line is the one count (ws.SprintCounts.Header, nova-tools #4411): the numbers sprint status, ws counts and the sprint table print, the streams' sentinels never counted. The bash printed sprint-xy's sprint:<S>:xy (or SPRINT-XY.txt, and a stale line when both were missing); that key is no longer read, and MaskXY is the one documented difference the parity control and --compare mask on both sides.

Keys (all read-only; each has one writer elsewhere):

friend:<f>            HMGET at up ready working done   (friend-row)
friend:<f>:down       GET, a set value prints "down"   (out-of-credits)
ws:order, ws:<s>:*,   the one count (ws.CountsReader): the memberships ride
ws:log, sprint:order  the SCAN walk's first round trip, every count the pipeline
s:<S>:pitstop         HGETALL, the pitstop verb's hash: the title reads
                      *** PIT STOP *** <why> since <at> (#3423, #3887)
bench:*               SCAN COUNT 1000, then HGETALL    (bench-row, card-dealer)
bench:<b>:cards:<w>   ZCARD, w = ready working done ok fail (the card move, #3692)
ci:nomirror:<b>       SMEMBERS, the repos the bench has no mirror of (ns_ci_release, #3724)
bench:_pool:cards:ready ZCARD, the pool line: cards not dealt (#2733)
sprint:<S>:cards      EXISTS, the sprint has cards: the pool line prints at 0

A host row's ready, working, done, ok and fail are the ZCARDs of its card views, read in the same pipeline (nova-tools#3692, ONE PLACE: every card is in one place, and these sets are the bench view of it). The bash bench-row's queue, working, done, ok and fail fields are no longer read: it counted job dirs, and cards that had ended printed as "-". host, at and load1 still come from the bench's own hash.

A host row ends " | nomirror=<repos>" while ci:nomirror:<b> is non-empty (#3804): every CI claim of those repos skips the bench until its mirror exists, so the defect is on the row; "?" when the set could not be read.

Bench keys are found by SCAN, as the bash does (a cursor walk; the bench ACL user has no KEYS and no EVAL_RO); every value is then read in ONE pipelined round trip.

sprint.go: the whole sprint table (#3530, part of #3662), the one screen Glenn watches, read from Redis once a second. It replaces the bash renderers of 2026-09-24 (a streams renderer that asked GitHub, an ETA script, sprint-table-redis for the host and friend blocks, and a shell loop that stitched their files together). Layout, one blank line between blocks:

SPRINT TABLE [*** PIT STOP ***]

<landed>/<total> done <z>%, left <l>, eta <HH:MM> ET gh <n>/h   (ws.SprintCounts.Header)

stream | waiting | ready | working | review | merging | landed   (rows in ws:order, all-zero rows hidden, total)
REVIEW stream=<s> over=<n> oldest=<id> age=<d> max=<d>     (a stream with cards in review past cfg:review max_age, #4072)

consumer | ready | working | done | ok | fail | ok% | status | load   (one row per consumer, total)

review is ZCARD ws:<s>:review: one state for every card past working that is not yet merging (Glenn 2026-09-26 8:20 AM ET, "let's do review": a card whose consumer copy failed and waits for its typed verdict (#4072), and a card whose PR waits for its read; the old reading set and the merging <read>/<unread> split (#3900, #3929) are gone). Every cell is one plain ZCARD; it is left, never done. The headline and the stream block are one read of ws.Counts (the one count, #4411): the headline's total is the total row's sum, and each stream's sentinel is counted nowhere (it is the stream's stop, not work: in no cell, no total, no x/y and no left).

The consumer table is ONE table (#4071, Glenn 2026-09-25 2:40 PM: "friends can fuck up cards too"): a row per consumer, friends and benches alike, named <kind>:<name> (friend:emma, bench:hetzner) so the kind shows. Every cell is one ZCARD of <kind>:<name>:cards:<set> for set = ready, working, ok, fail; done = ok + fail and ok% = ok / done are derived, never stored, with no sprint window and no base from a clear. The cells count consumer work only, by structure (nova-tools#4237): a record naming a probe is refused by every move into <kind>:<name>:cards:<set> (cm_zadd and the move gates in 02_card_move.lua), and a probe's result lives on the bench beat (bench:<b>:beat probe, fleet build), which this table never counts; after sprint clear and a fleet roll every row reads 0 | 0 | 0 | -. status is up when the consumer's own beat (<kind>:<name>:beat at, ms) is under a minute old and <kind>:<name>:down does not exist, else down (the row still shows its cards); an up consumer whose desired hash has paused 1 (worker pause, #4308) prints paused instead; an up bench whose last fleet play stopped (bench:<b>:play result failed:<role>, #4356) prints behind: <role>; load is the beat's cpu or load1 (a bench beat's, or a friend beat's, which nova-friend's beat measures on the machine the friend's session runs on, #4233; - when the beat has none). The old friend:<f> row hash and bench:<b> hash are never read, and no friend's load is read from another consumer's beat.

Keys, every one read in ONE pipelined round trip per tick (a second round trip only on the tick a membership set changed; never KEYS, never SCAN):

ws:order                ZRANGE, the streams in rank order (the ws index, #3662)
ws:<s>:<state>          ZCARD for waiting, ready, working, review, merging, landed, parked
ws:log                  XRANGE over the last hour: the landed rate for the ETA
sprint:order, s:<S>     ZRANGE and HGET status, no sprint named: the open sprint
friends, benches,       SMEMBERS: the consumers (friends the --friends roster
consumers               when given; then the benches; then any other
                        enrolled consumer), each once
<c>:cards:<set>         ZCARD for set = ready, working, ok, fail
<c>:beat                HMGET load1 at ncpu cpu models
<c>:down                EXISTS (a string or a hash; either means down)
<c>:desired             HGET paused (1: the status reads paused while up)
bench:<b>:play          HGET result (failed:<role>: the status reads behind: <role>)
s:<S>:pitstop           EXISTS, with the legacy sprint:<S>:pitstop

The membership of ws:order, friends, benches and consumers is kept from the previous tick, so the tick's one pipeline reads the sets and every member's values together; a tick that finds a set changed reads again at once with the new ones, so a row is never rendered from last second's membership.

streams.go: the stream block as a nova-table (internal/ntable). Glenn 2026-09-27: "The work stream table is really just a series of ordered sets, per-cell" / "and the value printed, happens to be for each cell, |s|". The streams table's rows are the streams of ws:order and its cells are BOUND to the sets the card model owns, ws:<s>:<state> under the epoch (ws.KeyAt), one count column per state of ws.Stream, each folding to its sum in the footer row total; the row labels are the stream names. Nothing is copied: the sprint tick reads every cell through ntable.QueueCells in its one pipeline (the ws.CellReader seam of ws.CountsReader, so the headline and the block are one count, #4411), renders the block through ntable.Render, and the sprint loop binds the table in the store (ntable.Bind) whenever its shape moves, so `nova-table render streams` prints the same block from the same sets. A row's excluded member is the stream's sentinel: the stream's stop, not work, counted nowhere (#4318).

Package table parses and renders the nova-sprint table from the single consistent snapshot returned by the ns_snapshot Redis Function. One call, one server instant: section 6 of #2756.