sprint

const (
	NAlarmReview  = "review above its alarm"
	NAlarmMerging = "merging above its alarm"
	NAlarmReady   = "nothing ready while cards wait"
	NAlarmFleet   = "the fleet works below its alarm"
	// NAlarmCleared is the happened note, to the coordinator, that an alarm's episode
	// ended: its what opens with the alarm's type and a colon.
	NAlarmCleared = "an alarm cleared"

	PropAlarmReview  = "alarm_review"  // a count: raised while review holds more
	PropAlarmMerging = "alarm_merging" // a count: raised while merging holds more
	PropAlarmFleet   = "alarm_fleet"   // a percent: raised while the up members work below it of their width
	PropAlarmReady   = "alarm_ready"   // on: raised while nothing is ready and a card waits
	// AlarmOff is the word that takes an alarm off.
	AlarmOff = "off"
)

The backlog alarms (docs/SPEC-SPRINT.md section 8, "Backlog alarms"): four conditions of the whole sprint the tick keeps, each off until the coordinator sets its threshold (`set --alarm-review`, `--alarm-merging`, `--alarm-fleet`, `--alarm-ready`, the work table's properties below). Each is one judgment while its condition stands, written once when it starts (notify: one per episode, so a push of new judgments pushes it once) and closed once when it ends, with one cleared note to the coordinator.

const (
	PropAttempts    = "attempts"
	FieldAttempts   = "attempts"
	AttemptsDefault = 4
	AttemptsMax     = 100
)

PropAttempts is the work table's property holding the sprint's attempt cap (set --attempts, init --attempts), FieldAttempts a stream's control card field holding the stream's (stream set --attempts), over the sprint's; AttemptsDefault is the cap when neither is set, and AttemptsMax the most a cap may be.

const (
	BriefDefectBase      = "the base lacks a PATHS file"
	BriefDefectDuplicate = "a duplicate of landed work"
	BriefDefectDecision  = "a decision delivered"
	BriefDefectPaths     = "PATHS do not hold what the brief names"
	BriefDefectOther     = "named by the worker"
)

The reasons a brief defect is recorded with (FieldBriefDefect), as BriefDefectOf reads them.

const (
	// TickTurnFloor is the least time the batches have the line between two ticks when
	// they wait for it: the run loop's TickFloor.
	TickTurnFloor = 100 * time.Millisecond
	// TickTurnCap is the most: with a tick and a batch each shorter, a tick of a loaded
	// server begins within 15 s (MachineSilence) of the tick before.
	TickTurnCap = 5 * time.Second
)

const (
	NFriendDeaf        = "a friend's session is deaf"
	NFriendIdle        = "a friend holds working cards and finishes none"
	NCoordinatorBehind = "judgments wait on the coordinator past their deadline"
	// NFriendEmpty is an up friend whose row has been empty for EmptyRowAfter while
	// cards she could do sit ready in the pool or unstarted on another friend's row.
	NFriendEmpty = "an up friend has an empty row while cards wait"
	// NPinIgnored is a named pin (WHO: friend <name>, not a hard pin) sitting ready
	// or working off that friend's row.
	NPinIgnored = "a pinned card was dealt away from its friend"
	// NFriendRowEmpty is the clock for NFriendEmpty: an acknowledgement, not a
	// judgment, written when an up friend's empty row and the cards she could do
	// first hold together, and closed when they do not. It is not one of PassTypes,
	// so a pass does not raise it and does not close it by the judgment rule.
	NFriendRowEmpty = "an up friend's empty row"
	// NRaisedAgain is the push of a pass judgment that still holds: a happened note to
	// the coordinator, once every PassEvery of running time.
	NRaisedAgain = "a judgment still holds: raised again"
)

The pass's judgment types and its push.

const (
	// PassEvery is the running time between two raises of one pass judgment.
	PassEvery = 10 * time.Minute
	// EmptyRowAfter is how long an up friend's row stays empty, while cards she
	// could do wait elsewhere, before the pass tells the coordinator once.
	EmptyRowAfter = 10 * time.Minute
	// FriendDeafAfter is how old a friend's last session pong may be before her
	// session is deaf: FriendProofLive, since her daemon asks her session eight minutes
	// after its last ask and waits up to five for the answer (nova-friend's ProveEvery and
	// SessionBound; docs/SPEC-FRIEND.md, The push proof), so a session that answers is
	// never proved longer ago than thirteen minutes. Shorter, and a friend whose session
	// answers slowly is judged deaf and cleared again every cycle.
	FriendDeafAfter = FriendProofLive
	// FriendFinishDefault is the friend-finish window when the coordinator set none.
	FriendFinishDefault = 30 * time.Minute
	// PropFriendFinish is the work table's property: the friend-finish window, a
	// duration (nova-sprint set --friend-finish).
	PropFriendFinish = "friend_finish"
)

const (
	// UsageSubscription is the usage word a subscription reader adds to its --usage.
	UsageSubscription = "billing=subscription"
	// WhySubscription is a subscription run's unpriced word: its tokens, no dollars.
	WhySubscription = "subscription"
	// CostTokens is the cost a COST line shows for a subscription run: its tokens.
	CostTokens = "tokens"
)

A read is priced as work is (the owner, 2026-10-05: "do we have the cost for readers properly calculated yet in nova sprint?"): by the route its ask drew, the read card's own route row, never by a route found again from the model its harness reported. A read card with a route is a routed read: its verdict (read --ok or --broken) carries the run's usage or is refused (ReadUsageMissing), so no routed reader can leave its read unpriced by saying nothing. A usage with no token count (a fleet harness that reported none) is permissive in what we read: the verdict is kept, its record says unpriced=no-tokens and the stream counts it (TierCosts.ReadsNoTokens). A subscription reader (a bud's claude -p on its own plan, which bills no dollar per token) says so in its usage, billing=subscription: its tokens are kept, with no dollar figure, and its cost is shown as tokens (CostTokens).

const (
	FieldCostRecord = "cost_record:" // + the consumer's key (Consumer.Key)
	FieldCostTotal  = "cost_total"   // cardcost.Total.String over every record
	FieldCostCut    = "cost_cut"     // how many records past MaxCostRecords were left out of the list
	// MaxCostRecords bounds the history on one card. A card's takes and reads are few;
	// past the bound a record is still added to the total, exactly, and counted in
	// FieldCostCut, and `card <id>` says the list was cut.
	MaxCostRecords = 64
)

The producer card carries what it cost, for the cost is tracked in the card: each consumer that ends appends one record to the primary, FieldCostRecord plus the consumer's key, in the same step that ends it, and the primary's running total (FieldCostTotal) is updated with it. Everything that shows or sums a card's cost reads the primary alone (CardCostOf), so no reader or member removed, no read card retired and no consumer record cleaned up can lose cost.

const (
	StageNeeds    = "needs"     // added to ready
	StageDeal     = "deal"      // ready to dealt (a card never reworked)
	StageTake     = "take"      // dealt to taken
	StageWork     = "work"      // taken to finished
	StageRework   = "rework"    // finished to dealt again, over every attempt (a reworked card)
	StageReadWait = "read_wait" // finished to read asked
	StageRead     = "read"      // read asked to read done
	StageAccept   = "accept"    // read done to accepted
	StageMerge    = "merge"     // merge queued to landed
)

Stage names, in the order wall time passes through them.

const (
	FieldReadyAt     = "ready_at"
	FieldDealtAt     = "dealt_at"
	FieldTakenAt     = "taken_at"
	FieldFinishedAt  = "finished_at"
	FieldReworkS     = "rework_s"
	FieldReadAskedAt = "read_asked_at"
	FieldReadDoneAt  = "read_done_at"
	FieldQueued      = "queued" // on the merge card
)

The stamps a card keeps on itself, beside admitted, accepted and landed.

const (
	// DeadlineK is the multiple of the member's median run wall a card's deadline is at
	// least.
	DeadlineK = 3
	// DeadlineSamples is how many of the member's latest ok attempts the median is over.
	DeadlineSamples = 50
	// FieldMemberDeadline is the member's control card field holding its pinned deadline
	// in seconds (fleet up --deadline), absent when none is pinned.
	FieldMemberDeadline = "deadline"
	// FieldOwnDeadline is the work card's own deadline in seconds, the route's or the
	// pin's, kept beside `deadline` (the member's) so a card dealt again to another
	// member (a member down, the level) gets that member's from the same start.
	FieldOwnDeadline = "deadline_own"
)

const (
	// FieldDecideAttemptNoResult and FieldDecideAttemptNothingToDo are a work card's attempt
	// bars, the sprint row's as the deal read them: a failed finish whose decision is that
	// class at or above its bar is routed by the class (finishKind).
	FieldDecideAttemptNoResult    = "decide_attempt_no_result"
	FieldDecideAttemptNothingToDo = "decide_attempt_nothing_to_do"
	// FieldDecided is a work card's attempt decision as its last finish carried it
	// (decide.Decided: `<class> p=<p> op=<op>`), and FieldDecidedUsed is "yes" when the
	// finish was routed by it.
	FieldDecided     = "decided"
	FieldDecidedUsed = "decided_used"
	// PrefixDecided keys a primary's record of each attempt decision of its takes:
	// `decided:<op>` = `<class> p=<p> used=<yes|no>`, set once (the op is per attempt and
	// state, so two takes that ended alike share it), read by DecideDue.
	PrefixDecided = "decided:"
	// FieldGrade is a primary's grade decision (decide.Decided: `<grade> p=<p> op=<op>`).
	FieldGrade = "grade"
)

The fields of layer 2.

const (
	NDriftAhead    = "the base is ahead of dev past its drift"
	NDriftCardBase = "an open card is cut on another base"
	NDriftServer   = "the live server runs off the base"
	NDriftBaseRed  = "the base is red at its tip"

	PropDriftCommits = "drift_commits" // a count: the base may be this many commits ahead of dev
	PropDriftHours   = "drift_hours"   // hours: the oldest commit of the base not on dev may be this old
)

The drift alarms (docs/SPEC-SPRINT.md section 8, "Drift alarms"). On 2026-10-04 and 2026-10-05 the branches drifted for hours before anyone looked: the live server on a side branch, cards on temporary and dead branches, and the base red three times through the lander's narrow gate, each blocking the promotion to dev. The owner, 2026-10-05: "How can we ensure that you ALWAYS do the merging properly from now on, vs. drifting and forgetting?" and "Prevention is better than cure". So every drift is a fact the machine raises: four judgments, each written once when its drift starts, raised again every PassEvery of running time while it holds (the judgment rewritten with the latest facts and its raises counted in Before, and a push NRaisedAgain to the coordinator, as the coordinator's pass does), never one a tick, and closed when it stops. The episode machine is the pass's, tla/CoordinatorPass.tla.

const (
	DriftCommitsDefault = PromoteCards
	DriftHoursDefault   = 2
)

The thresholds of the base ahead of dev when the coordinator set none: as many commits as PromoteCards, and two hours.

const (
	FieldFailure      = "failure"
	FieldFailureAt    = "failure_at"
	FieldFailureTier  = "failure_tier"
	FieldFailureBound = "failure_bound"
	FieldFailureBack  = "failure_back"
	FieldIdenticalAt  = "identical_at"
)

The primary's record of its failed work, written by the failed finish (Finish) and by the rework of an attempt at its redeal bound (Rework: its takes ended with no work to judge, BoundClass): the class of the last failed attempt, that attempt and the tier the card was on (CardTiers: a new tier counts its own failures), whether it ended at its bound, and the attempt whose failure was the same as the attempt before's (rule 2): the tick holds the bound's judgment on the primary while it stays in review at that attempt (AtIdenticalFailure). FieldFailureBack is the tiers on which the provider's return has lifted a held bound (providerBack), comma separated: once per tier per card, and nothing clears it.

const (
	FieldAdoptSince  = "adopt_since"
	FieldAdoptTo     = "adopt_to"
	FieldAdoptFailed = "adopt_failed"
)

The control card's fields of an adoption: the episode (when the member was held adopting, the key of its one adoption), the release it adopts, and the failure that keeps it held.

const (
	NMemberBack  = "fleet member back"
	NAdoptFailed = "a member's adoption failed"
)

NMemberBack is the happened note of a member back from down at the latest; NAdoptFailed the judgment of one whose adoption failed.

const (
	AdoptNone     = ""
	AdoptRunning  = "running"
	AdoptFinished = "done"
	AdoptFailed   = "failed"
)

The states of one machine's adoption.

const (
	NQuiet      = "a machine is quiet"
	NQuietEnded = "a machine's quiet ended"
)

The happened notes of a quiet: begun by the coordinator, and ended, at its time or early.

const (
	FieldHeldBy = "held_by"
	HeldBySync  = "sync"
)

FieldHeldBy is the control card's field naming who made the member's hold when it was not the coordinator; HeldBySync is the sync.

const (
	DriftAdd     = "add"     // the inventory names a member the table has no control card for
	DriftWidth   = "width"   // a member's width differs
	DriftHold    = "hold"    // the table has a member the inventory no longer names
	DriftRelease = "release" // a member the sync held is back in the inventory with room
	DriftRemove  = "remove"  // a member with no machine row on which no card stays
)

The kinds of drift between the fleet table and the inventory.

const (
	CheckAnswerWithin = 15 * time.Minute
	MaxAsked          = 8
)

CheckAnswerWithin is how long after the ask an answer to a check proves; MaxAsked is how many unanswered checks her beat record keeps, the oldest dropped first.

const (
	FriendTaskQueued  = "queued"
	FriendTaskWorking = "working"
	FriendTaskDone    = "done"
)

The states of a task in a friend's QUEUE.json.

const (
	ReconcileCollect = "collect" // her report is there: friend sync's finish
	ReconcileKeep    = "keep"    // she holds it: left working
	ReconcileReturn  = "return"  // she does not: FriendReturn
)

What reconcile does with one card working on a friend's row (FriendReconcileOf).

const (
	NFriendCollected = "a friend's card collected by reconcile"
	NFriendDisagrees = "a friend's row disagrees with her QUEUE.json"
	NFriendAgrees    = "a friend's row agrees with her QUEUE.json again"
	// NFriendDirStalled is the run loop's reconcile passing a friend over because a read
	// of her directory did not answer within its deadline (cmd/nova-sprint
	// friendreconcile_tick.go), once an episode
	NFriendDirStalled = "a friend's directory did not answer the reconcile"
)

The run loop's reconcile notes: happened, addressed to the coordinator (the tick end wakes them, and inbox --push carries them to the bus).

const (
	// NFriendSyncFailing is the judgment: friend sync has refused every pass past the bound.
	NFriendSyncFailing = "friend sync keeps refusing"
	// NFriendSyncRefusing and NFriendSyncRecovered are the log's happened notes of the
	// state's record and its clearing.
	NFriendSyncRefusing  = "friend sync refusing"
	NFriendSyncRecovered = "friend sync ok again"
	// PropFriendSync is the fleet table property holding the loop's standing failure
	// (FriendSyncState as JSON); absent or empty while the loop is ok.
	PropFriendSync = "friend_sync"
	// FriendSyncJudgeAfter is how long the loop fails before it records the state the
	// judgment is raised on: one minute, four passes of the 15 s loop.
	FriendSyncJudgeAfter = time.Minute
)

The friend sync loop's standing failure, told once (docs/FRIENDS.md, "The friend sync loop"). On 2026-10-08 the loop refused every pass from 01:05 to 08:51 ET ("schema config is at version 35 and this binary carries 36; run: nova-config migrate") and for 7h45m no friend card was delivered or collected and no width followed nova-config; nobody was told, because the loop wrote its one FAILING line to its own log and raised no judgment. Now a loop failing past FriendSyncJudgeAfter records its state on the fleet table (PropFriendSync, FriendSyncState), the tick's deal raises one judgment of type NFriendSyncFailing on it (friendSyncConds, one open at a time: notify), and the first ok pass clears the state, which closes the judgment. The loop keeps retrying as before; the judgment is the coordinator's to see, with the refusal and its remedy in it, and nothing to answer but ack or wait.

const (
	// FieldTakenBack is why a friend's work card was taken back, on the withdrawn card until
	// the deal places it again: "taken back by the coordinator: <reason>", or the hold's words.
	FieldTakenBack = "taken_back"
	// FieldTakenFrom is the friend's row the coordinator took the card back from (friend
	// take, not the hold): the deal that places it again never gives it back to her.
	FieldTakenFrom = "taken_from"
	// NTakenBack is the happened note of a friend's card taken back to ready.
	NTakenBack = "a friend's card taken back to ready"
	// FieldCarryHead is the head a started card had pushed when a hold took it back, and
	// FieldCarryGen the generation whose branch holds it (BranchOf at that generation): the
	// next generation starts from it. Both stay on the card through its next deal.
	FieldCarryHead = "carry_head"
	FieldCarryGen  = "carry_gen"
)

const (
	GCJobs    = "jobs"
	GCReads   = "reads"
	GCLanders = "landers"
	GCBench   = "bench"
	GCCache   = "cache"
)

The classes, in the order a pass says them.

const (
	GCLaneNone  = ""      // the log never names the job
	GCLaneLive  = "live"  // started, resumed or stopped at a limit (it runs again), not ended since
	GCLaneEnded = "ended" // its last event is an END
)

The states of a job's lane in its runner's log (GCLane).

const (
	HeldByActor    = "a"    // an outside actor, before its deadline
	HeldByTick     = "b"    // the next tick moves it or writes its judgment
	HeldByJudgment = "c"    // an open judgment names it
	HeldByWaiting  = "d"    // it waits on something held
	HeldByStopped  = "e"    // the machine is STOPPED; the next tick would move it
	HeldDone       = "done" // landed, or off the table: nothing is owed
)

The holders, as Holder names them.

const (
	WaitOnCards   = "card"
	WaitOnLine    = "line"
	WaitOnRelease = "release"
)

The one wait (docs/SPEC-ISA.md): a held card waits for release, a sentinel for its line, and the wave behind it for the release through its card operand.

const (
	HoldMember = "member"
	HoldReader = "reader"
	HoldFriend = "friend"
	HoldStream = "stream"
)

What a hold names.

const (
	FieldHeldReason = "held_reason"
	FieldHeldFinish = "held_finish"
)

FieldHeldReason is a held member's or stream's control card's reason for its hold, and FieldHeldFinish marks a member's hold that lets its working cards finish (hold with no --return): the rebalance's sweep leaves those cards where they are.

const (
	NIdle        = "the fleet is idle"
	NIdleCleared = "the fleet is working again"
)

The idle alarm's notes: happened, addressed to the coordinator (the tick end wakes them, and inbox --push carries them to the bus).

const (
	// IdleWindow is how long, in running time, the fleet works under half its width with
	// cards waiting before the alarm is pushed.
	IdleWindow = 5 * time.Minute
	// IdleRoots is how many roots the note names, the most cards behind first.
	IdleRoots = 8
	// PropIdleSince and PropIdleSaid are the fleet table's properties of an episode: when
	// it began and when its note was pushed ("" or absent: none).
	PropIdleSince = "idle_since"
	PropIdleSaid  = "idle_said"
	// PartIdle is the tick part's name.
	PartIdle = "idle"
)

The idle alarm's numbers and state.

const (
	// FieldRuleReread is the primary's attempt at which the read-late rule asked another
	// reader: once an attempt, the second late read of the attempt is a mind's.
	FieldRuleReread = "rule_reread"
	// FieldRuleNeed is the card a HOLD named that the hold-need rule waits for, with the
	// attempt that held: "<card>@<attempt>".
	FieldRuleNeed = "rule_need"
)

The fields these rules write.

const (
	PartRuleTake = "rule take"
	PartRuleAsk  = "rule ask"
	PartRuleNeed = "rule need"
)

The tick parts of these rules (TickRules).

const (
	// NStatus is the status transition's judgment type.
	NStatus = "status"
	// RuleStatus is the rule that answers a status judgment whose every step is done. It
	// is not in RuleNames (nova-config's answer_rules_off enum does not name it yet), so
	// only run --answer-rules=false turns it off.
	RuleStatus = "status"
	// TakeWithin is how recent a take of hers must be for a friend come up to be in the
	// sprint (the fourth step).
	TakeWithin = 10 * time.Minute
	// StatusDwell is how long a row must hold a status other than its recorded one, in running
	// time, before the change counts as a transition.
	StatusDwell = 2 * time.Minute
	// StatusFlapsRaise is how many flaps (a departure back inside the dwell) raise the row's
	// "flapping" judgment when none is open: once, until a transition counts.
	StatusFlapsRaise = 3
	// StatusFlapWindow is how long, in running time, the flaps that raise it may take: a count
	// short of StatusFlapsRaise that began longer ago starts again at the next flap.
	StatusFlapWindow = 10 * time.Minute
	// StatusRuleAfter is how long after a status judgment's last push the rule may answer it.
	StatusRuleAfter = 60 * time.Second
	// NStatusChanged is the push of a status judgment whose text a further transition
	// replaced: a happened note to the coordinator naming it.
	NStatusChanged = "a status judgment changed"
)

const (
	BuildSame      = "same"
	BuildDifferent = "different"
	BuildUnknown   = "unknown"
)

The answers of BuildMatch.

const (
	FieldBaseGatePassed     = "base_gate_passed"
	FieldBaseGatePassedStop = "base_gate_passed_stop"
)

FieldBaseGatePassed is the base commit the lander found green again, on the control card of a stream stopped on its base's red (cause base); the base-gate rule resumes the stream. FieldBaseGatePassedStop is the stop it was found for (the card's since): a mark left from an earlier stop (a hand resume does not clear it) is no mark (basePassed).

const (
	// LaneGo is the lane kind of a Go build or test run: one per machine unless the
	// sprint's setting says otherwise (PropGoLanes).
	LaneGo = "go"
	// LaneHoldFor is how long a holder keeps its lane without taking it again: past a
	// whole gate run of `go test -timeout 600s` with room for its build, so a worker
	// that exits without giving it back (killed, lost) frees it.
	LaneHoldFor = 20 * time.Minute
	// LaneWaitFor is how long a waiter keeps its place without asking again, and how
	// long a grant made while it was not asking waits for it to claim it.
	LaneWaitFor = time.Minute
	// LaneAskEvery is how often a waiting take asks again (lane take --wait): well
	// inside LaneWaitFor, so a waiter that is there never loses its place.
	LaneAskEvery = 5 * time.Second
	// LaneWidthDefault is a machine's lanes of a kind when the sprint sets none: the
	// one test stream per machine.
	LaneWidthDefault = 1
	// PropGoLanes is the work table's property: the Go lanes of every machine, a
	// whole number from 1 (`set --go-lanes`).
	PropGoLanes = "go_lanes"
)

const (
	FieldLaneCap     = "lane_cap"
	FieldLaneOverrun = "lane_overrun"
	FieldCapRedealt  = "cap_redealt"
)

The fields of a capped take: on the work card the cap and the overrun its finish named, and on the primary the re-deal the cap spent (`<from> -> <to>`), once per card.

const (
	Mechanical  = "mechanical"
	Coordinator = "coordinator"
)

The class of a move: mechanical moves need no decision; the coordinator's moves are made only by the coordinator's verbs.

const (
	PropMergeWindowUntil  = "merge_window_until"
	PropMergeWindowReason = "merge_window_reason"
)

The merge window's properties, the merge table's (merge-window open): its end, RFC 3339 in UTC, and its reason. A clear starts the next epoch with neither, as it starts every property.

const (
	NeedJudgment = "judgment" // an open judgment of the inbox
	NeedSentinel = "sentinel" // a sentinel reached, or held, that waits for its release
	NeedStream   = "stream"   // a stopped stream with no judgment open on it
	NeedHeld     = "held"     // a card admitted held (add --held) that waits for its release
)

The kinds of a Need.

const (
	Happened = "happened" // no decision
	Judgment = "judgment" // needs the coordinator
	Decided  = "decided"  // a judgment answered
	// Acknowledged is a judgment of the tick the coordinator acknowledged
	// while its condition held: kept on the condition's subjects, it is no
	// judgment and shows in no inbox; it stops the tick from writing the
	// judgment again until the condition has cleared (the tick then closes
	// it) and come back.
	Acknowledged = "acknowledged"
)

Notification kinds (docs/SPEC-SPRINT.md section 8).

const (
	NStartedMerging = "stream started merging"
	NBatchLanded    = "batch landed"
	NStreamLanded   = "stream landed"
	NWorkOK         = "work came back ok"
	NMemberUp       = "fleet member up"
	NMemberDown     = "fleet member down"
	NUnknownMachine = "an unknown machine is beating"
	NStagingRefused = "a member refused a card at staging"    // dealt to another member
	NRestWithdrawn  = "a card withdrawn from a resting route" // dealt again on one that serves
	NFriendReturned = "a friend's card returned to ready"     // by friend reconcile: no report, and her queue says done or does not hold it
	// The landing refused a card's head (it does not merge on the base's tip, or fails the tree
	// gate the base passes): the card was reworked at the tip and its stream landed on
	// (landRefused, redo.go). Addressed to the coordinator; nothing to answer.
	NLandRefused = "the landing refused a card's head: reworked at the tip"
	// The coordinator held a fleet member, a reader, a friend or a stream, or released
	// its hold (hold, unhold: hold.go), the reason in the note.
	NHeld   = "held by the coordinator"
	NUnheld = "released from a hold"

	// The tick's own failure, noted once for each distinct error text it
	// keeps failing with, and its recovery, noted once with the count of
	// failed ticks (docs/SPEC-SPRINT.md section 14): both are happened notes
	// addressed to the coordinator, so the tick end wakes it.
	NTickFailed    = "the tick failed"
	NTickRecovered = "the tick recovered"

	// Computed by inbox from the machine's record, as the stale line is: no
	// notification holds them.
	NMachineSilent  = "the machine is not ticking"
	NTickFailing    = "the tick keeps failing"
	NStoppedWithDue = "the machine is STOPPED and moves are due"
	NWithdrawn      = "cards returned to ready because no member is up"
	NCIGreen        = "ci green"
	NAbandoned      = "an operation was abandoned"
	NSentinelLanded = "sentinel landed" // released by the coordinator

	// The coordinator's seat moved (docs/SPEC-SPRINT.md, "Handing over the
	// seat"): given by its holder or the owner, or taken with the owner's name,
	// which is addressed to the holder it was taken from.
	NSeat           = "seat"
	NFriendNotWoken = "a friend was not told of her card" // friend sync delivered it, and the bus message to her failed
	NSeatTaken      = "seat TAKEN"

	NReadyToAccept   = "ready to accept"    // the readers it needs said ok at its head (ReadsNeeded)
	NReturned        = "returned to review" // sent back from merging: the coordinator decides again
	NWorkFailed      = "work came back failed"
	NBriefDefect     = "a brief defect" // a HOLD naming the brief: re-cut it (brief_defect.go)
	NReadBroken      = "a reader found it broken"
	NBriefWrong      = "a card has reached its bound: the brief is wrong, not the worker" // brief_bound.go
	NReadReturned    = "a reader returned a read"                                         // no verdict, not a read: asked again
	NConflict        = "stream stopped: conflict on a card"
	NRed             = "stream stopped: stream branch red"
	NCross           = "stream stopped: needs a card of another stream first"
	NRejected        = "stream stopped: the merge queue rejected"
	NBaseRed         = "stream stopped: the base fails its tree gate" // the base-gate rule's third failure (rules.go)
	NMissingBase     = "the base branch is gone"                      // a land whose base branch is missing (rebase.go)
	NBlocked         = "a primary is blocked on something dropped"
	NMissingNeed     = "a primary is blocked on something missing"
	NCIRed           = "ci red"
	NReadsExhausted  = "reads exhausted"
	NStranded        = "stranded in review" // failed work acknowledged, or never asked, and nothing open
	NRepairSkipped   = "repair skipped changes the store refused as recorded"
	NOpStuck         = "an operation was stuck"
	NOverdue         = "a judgment notification has waited past its deadline"
	NStreamStale     = "a stream has not changed state or count past its deadline"
	NSprintDone      = "the sprint is done"
	NSentinelReached = "sentinel reached" // a stop: the coordinator decides before going on
	NRepeatSuffix    = "; a second time for the same cause"
)

Notification types. A type is what happened; judgment types name the decisions open to the coordinator.

const (
	TimeoutStaging  = "stage-timeout"
	TimeoutDeadline = "deadline"
	TimeoutUsage    = "usage source"
)

The timeout kinds a member's finish reports (member.Judge): a launch refused at staging on the stage's own timeout, a child its deadline ended, and a child the budget rule ended because the usage source stopped answering within its bound.

const (
	FieldBriefOp     = "brief_op"
	FieldBriefRecord = "brief_record"
)

FieldBriefOp and FieldBriefRecord are the card's brief decision (internal/decide, docs/SPEC-NOVA-DECIDE.md section 14): the op id add asked it under and the record that holds it, written when add asked one, so land and drop attach the card's end to that decision by its exact id; both absent when none was asked.

const (
	FieldReadBranch     = "read_branch"
	FieldReadBranchHead = "read_branch_head"
)

FieldReadBranch and FieldReadBranchHead are a primary's record of the branch origin holds its attempt's head on, when a read named one origin does not hold (ReadReq.Missing): the server found the work's branch with that head, and every read of that head names it from then on.

const (
	PropTwinBriefs = "twin_briefs"
	EnvTwinBriefs  = "NOVA_SPRINT_JOBS"
)

PropTwinBriefs (the work table's property) and EnvTwinBriefs (the machine's environment) name the directory the paths rule writes a twin's brief under, one directory a card (its job directory); the property over the environment, and with neither <home>/nova-sprint/jobs.

const (
	ActTwin    = "replace by its widened twin" // no proposed file is shared
	ActTwinCmd = "left with its twin command"  // a proposed file is shared: a mind's, the command printed

)

The paths rule's acts.

const (
	// BeatDeadline is how long a beat is fresh, and so the length of one beat
	// window: a window with no beat after the last is one missed beat.
	BeatDeadline = 15 * time.Second
	// MissedBeatsDown is how many beat windows in a row a member misses before
	// it is down: one missed beat is a store round trip that timed out or a
	// slow machine, and marking a working member down on it withdrew its card
	// and lost the child's finish (the member's beat is one store call of
	// several seconds on a tailnet); three in a row is a member that is gone.
	// A beat between misses resets the count: it is derived from the last
	// beat, never stored.
	MissedBeatsDown = 3
	// LoadWindow is the span of beats whose highest load the load cell shows.
	LoadWindow = 10 * time.Second
	// FriendBeatEvery is how often a friend's daemon beats (friend beat). The
	// beat is recorded and shown (her report, her load, its age), and it never
	// makes her up: it proves a daemon, not a session (FriendStatus).
	FriendBeatEvery = time.Second
	// FriendProofLive is how old the session proof her beat carries may be while she is
	// up (docs/SPEC-FRIEND.md, The push proof): her daemon asks the session eight
	// minutes after its last ask and waits up to five for the answer (nova-friend's
	// ProveEvery and SessionBound), so a session that answers is never proved longer
	// ago than thirteen minutes, inside this window. The owner, 2026-10-05: "nova-bus is useless if the friend using it
	// is deaf and is not listening to messages sent back."
	FriendProofLive = 15 * time.Minute
	// FriendPongWindow is how long a wake ping her session answered keeps her
	// up, and FriendFinishWindow how long a card of hers finished (working to
	// done) does (docs/SPEC-FRIEND.md, "Presence is her session's evidence").
	// The owner, 2026-10-05 ~9:30 AM ET: "there is no value in things that are
	// answered just by the daemon"; a friend is up only when her session
	// answered a wake ping within ten minutes or she finished a card within
	// thirty. On 2026-10-04 friends read up for hours on beats sent for them
	// while their sessions took no turn.
	FriendPongWindow   = 10 * time.Minute
	FriendFinishWindow = 30 * time.Minute
)

const (
	PriorityBlocker  = "blocker"
	PriorityCritical = "critical"
	PriorityFix      = "fix"
	PriorityHigh     = "high"
	PriorityReader   = "reader"
	PriorityNormal   = "normal"
	PriorityLow      = "low"
)

The priority ladder, highest first.

const (
	PropPromotedAt  = "promoted_at"
	PropPromotedSha = "promoted_sha"
)

The work table's properties of the last promotion: when, and the merge sha.

const (
	// FieldLandProtected is a stream's control card's field: the repositories, comma
	// separated, whose protected branches the stream is marked to land on, or
	// LandProtectedAny for every repository; written by `stream set --land-protected`.
	FieldLandProtected = "land_protected"
	// LandProtectedAny marks a stream for the protected branches of every repository,
	// a card naming no repository among them.
	LandProtectedAny = "any"
)

The protected branches (docs/SPEC-SPRINT.md section 7): the lander never lands on a protected branch of a repository unless the card's stream is marked for that repository: a card cut on dev lands straight onto it and ejects the merge queue's promotion run, so a stream lands on its sprint branch and promotion is the marked stream.

const (
	NProviderFunds = "a provider is out of funds"
	NProviderLow   = "a provider is low on funds"
	NProviderKey   = "a provider refuses its key"
)

The provider's judgments, one per provider while its routes rest for the cause, subject ProviderSubject(provider).

const (
	PushProofEvery  = 10 * time.Minute
	PushAnswerBound = 5 * time.Minute
	PushProofLive   = PushProofEvery + PushAnswerBound
	PushRetry       = time.Minute // how soon a failed delivery is tried again
)

PushProofEvery is how often the push loop proves the seat again by the same round trip; PushAnswerBound is how long a check waits for its pong before the loop asks again; PushProofLive is how long a pong stands for the seat.

const (
	// RateWindow is the running time the rate is measured over: the last hour,
	// the window of the dashboard's throughput tile, so the two agree.
	RateWindow = time.Hour
	// RateFloor is the fewest landings in the window the rate is taken from;
	// with fewer, it is the whole sprint's average.
	RateFloor = 5
)

The landing rate the ETA is measured at (docs/SPEC-SPRINT.md section 1).

const (
	RetiredByLate     = "late"
	RetiredByPrimary  = "primary"
	RetiredByReturned = "returned"
	// RetiredByAway is a read card the machine took back off a reader down, away or held,
	// or off a resting route (RetiredByRest): it spends nothing of the reader's.
	RetiredByAway = "away"
	RetiredByRest = "rest"
	// RetiredByCards is a readers-table read asked and not begun, taken back when read cards
	// came on: dealt again as a read card.
	RetiredByCards = "read cards"
	// RetiredByUnstarted is a read card left in ready past the deal bound: the machine's
	// take-back, spending nothing.
	RetiredByUnstarted = "unstarted"
)

The retired_by of a read card the read-card ask takes back: past its deadline, or its primary no longer in review at the card's attempt (reworked, its brief replaced, dropped, accepted); RetiredByReturned is a read handed back with no verdict (read --return).

const (
	// ReaderUp, ReaderAway and ReaderDown are a reader's states.
	ReaderUp   = "up"
	ReaderAway = "away"
	ReaderDown = "down"
	// ReaderRetired is a reader the coordinator retired (reader retire): held
	// away for good, its beat writing none and its queue answering reader false,
	// its row and read cards kept, the history (the comfort list of 2026-10-03,
	// item 6); reader up brings it back.
	ReaderRetired = "retired"
	// ReaderHeld is a reader the coordinator holds (hold <reader>, hold.go): asked
	// nothing, its reads asked and not begun asked of another, its reads begun
	// finishing unless the hold took them back (--return).
	ReaderHeld = Held

	// ReaderBeatBound is how long a reader stays up after its last beat: the
	// fleet's bound (BeatDeadline), named once so a reader's can be told apart.
	ReaderBeatBound = BeatDeadline
)

const (
	// RetiredByRefused is the retired_by of a read its reader refused to launch.
	RetiredByRefused = "refused"
	// FieldRefused is why the reader refused it, as its return said.
	FieldRefused = "refused_why"
)

A read refused (docs/SPEC-SPRINT.md section 6, a read refused is not a read): a read its reader hands back because it could not launch it (cardhdr.EndLaunch: no route, a slot it cannot make) never ran, so it is no read, no re-ask and no mark against its reader. The return retires it off that reader (RetiredByRefused, the reason in FieldRefused) and the ask asks the read of another reader of its tier; the reader that refused may be asked it once more at the attempt (ReadCardForAsk's second identity), as a reader taken back away may. When no reader is left free at the attempt and one refused it for no route (refusedNoRoute), the tier's one judgment says so (NNoRoute, TickDeal) and the card stays in review: the readers stay up and are asked their next reads. On 2026-10-06 every fleet reader was asked heavy reads it had no route for, each return was counted toward the re-ask bound as a read, and the readers were spent at the attempt.

const (
	FieldReasked  = "reasked"
	MaxReadReasks = 2
)

FieldReasked is how many times a read card's reader returned it and it went back to asked on the reader's row, counted by Read itself at each return, so the bound holds whatever the tick does and however many readers are up (the ask need not run for the count to move); MaxReadReasks is the most: the return after them retires the card, counted as a read (tla/DirtyTick.tla, MaxReasks and ReasksBounded).

const (
	CoordinatorReaderPrefix = "coordinator:"
	HeavyKind               = "heavy"

	FieldHeavyReader    = "heavy_reader"
	FieldHeavyKind      = "heavy_kind"
	FieldHeavyVerdict   = "heavy_verdict"
	FieldHeavyEvidence  = "heavy_evidence"
	FieldHeavySHA       = "heavy_evidence_sha256"
	FieldHeavyReason    = "heavy_reason"
	FieldHeavyAttempt   = "heavy_attempt"
	FieldHeavyHead      = "heavy_head"
	FieldHeavyAt        = "heavy_at"
	FieldHeavyOverrules = "heavy_overrules"
)

The coordinator's heavy read (docs/SPEC-SPRINT.md section 6, accept-heavy-verdict-b.w1): accept --heavy records the coordinator's own read of the primary's attempt and head on the primary, under coordinator:<actor>, with the evidence file it read and that file's sha256, and it counts as one ok read toward the card's read rule (ReadsNeeded). It is never a reader's read: no read card is written for it, no reader row names it, and the readers field names the readers' oks alone. A reader's broken read at the same attempt stays as the reader left it, named on the primary as overruled.

const (
	ReaderSpendCol     = "spend"
	ReaderSpendHourCol = "spend_1h"
	ReaderPerReadCol   = "per_read"
	ReaderPricedCol    = "reads_priced"
)

The readers table's spend columns, as the where view is to show them: what its reads cost all time and in the last hour, dollars and cents rounded up ("-" when none of its reads was priced), what a priced read cost on average, and how many of its reads were priced.

const (
	BackupNone   = "none"
	BackupReads  = "reads"
	BackupMerges = "merges"
)

The backup states (Backup): reads when review exceeds working, merges when merging exceeds review and working together (it names the further bottleneck when both hold), none else.

const (
	MaxReadsWindowLines = 200
	ReadsWindowSpan     = 30 * time.Minute
	ReadsWindowMin      = 10
	ReaderWindowLen     = 20
	ReaderBreaksBar     = 0.8
	ReaderOtherBar      = 0.5
	ReaderOtherMin      = 5
	FindingClassLen     = 60
)

The bounds of the ledger and of the two notices.

const (
	NBrokenReadsOutrun = "broken reads outrun ok reads"
	NReaderBreaks      = "a reader breaks nearly everything"
)

The tick's two judgments.

const (
	FieldReturnedByDev     = "returned_by_dev"
	FieldReturnedByDevTier = "returned_by_dev_tier"
	FieldReturnedByDevSha  = "returned_by_dev_sha"
)

A landed primary's record of being returned by dev or an audit (Promoted, `promoted --returned <ids>`): when, the tier its reads ran on then, and the promotion's sha.

const (
	CheckCardsSettled     = "cards-settled"
	CheckBaseGateGreen    = "base-gate-green"
	CheckTwoOKReads       = "two-ok-reads"
	CheckProseTrue        = "prose-true"
	CheckLandingsPromoted = "landings-promoted"
	CheckNoOpenJudgment   = "no-open-judgment"
)

The six check names, in registry order.

const (
	RouteFile = "file"
	RouteBus  = "bus"
)

Route kinds.

const (
	// PropDealIndex is the fleet table's property: the deal's counter, a
	// decimal uint64 (round).
	PropDealIndex = "deal_index"
	// PropAskIndex is the readers table's property: the ask's counter round
	// the readers, a decimal uint64 (round).
	PropAskIndex = "ask_index"
	// PropStreamIndex is the work table's property of the deal: its counter
	// round the streams, moved past the stream of each primary dealt
	// (streamTurns). PropAskStreamIndex (the readers table's: the ask is the
	// readers' update) and
	// PropAcceptStreamIndex are the ask's and the accept's: each step that
	// takes cards across the streams keeps its own, so that one step's move
	// never resets another's rotation (a shared index moved by an ask of one
	// stream's card sends the next deal back to the stream after it, every
	// tick, and a third stream waits).
	PropStreamIndex       = "stream_index"
	PropAskStreamIndex    = "stream_index_ask"
	PropAcceptStreamIndex = "stream_index_accept"
)

The deal goes round the fleet and the ask goes round the readers: each keeps a rolling index into its names, in name order, modulo their number, that moves on with every card dealt (every read asked) past the name it went to. A deal scans the members from the index, wrapping, and takes the first that is up and has room for the card (a member down or full is skipped, and the index moves past the member dealt to, so a skipped member's turn is not given to its neighbour twice); an ask scans the readers from the index and takes the first that has no read card at the attempt and is not already chosen. So with every member idle consecutive deals go m1, m2, ..., mN, m1, ..., and over a run every member's done is within a few of the others; the shortest queue with its ties broken by name, which this replaces, gives every card of an idle fleet to the first members in name order and the tail of the fleet none.

Every placement of a card on a member goes through the deal's index and moves it, first attempts and redeals and levelling alike: the deal (R6, T3) and the withdrawn card dealt again, the rework of failed or broken work (R10, the coordinator's rework), the cards of a member that goes down (R2, fleet down and the tick's presence) and the levelling (R7, T4, fleet up and level). A rework skips the member of the attempt it sends back while another up member has room. The model is tla/SprintEvents.tla: RoundOne from dcur in PlanDeal, PlanDown, PlanRework and PlanLate, and dcur moved by each of their effects; the reference model's PlaceOn, ReworkChoice and levelRound.

The index is a property of the fleet table (the deal's, deal_index) and of the readers table (the ask's, ask_index), the owner's ruling ("a property of the reader table and the fleet table respectively; not a property of the work stream"): the index's counter (round), read with the table and written by the step that deals (asks) in the same atomic batch as its cards, guarded on the value the step read (Plan.Props; the table layer's properties). So it is atomic with the deal and survives a stop and a start of the machine and a new loop, and a clear starts the next epoch at counter 0, the first name. The model is tla/SprintEvents.tla: dcur and acur, moved by the deal's and the ask's effects, and PlanDeal's and PlanAsk's choice from them (RoundAssign, RoundTwo).

const (
	FieldRoute    = "route"
	FieldModel    = "model"
	FieldTokens   = "tokens"
	FieldUSD      = "usd"
	FieldHarness  = "harness"
	FieldDeadline = "deadline"
	FieldRoutes   = "routes"
	FieldUsage    = "usage"
	RoutePin      = "pin"
	// FieldTier is the primary's tier when the coordinator pinned it to one (rework
	// --tier): every later deal and read of the card draws from it, over its brief's
	// line 1, and the machine never escalates it (cardTier, NextTier); on a work or read
	// card, the tier its route was drawn from, which its packet hands the child or reader,
	// its JOB.md names and its cost record keeps.
	FieldTier = "tier"
	// FieldTierNow is the tier the primary is on, written by every deal on a route:
	// flash first on every card, then the tier the machine escalated it to (NextTier);
	// the tier its brief's line 1 names is its ceiling. Add writes pro on a card whose
	// gate's measured wall is over the flash bound (gate_wall.go).
	FieldTierNow = "tier_now"
)

The work card's route fields, written at each deal and redeal: the route taken (or RoutePin), the model id the member launches (provider/model), its budget and its deadline in seconds; the primary's FieldRoutes is every route taken for it, in order, the exclusion's history.

const (
	NRouteWoken               = "a route serves again: the coordinator woke it"
	NRouteRestedByCoordinator = "a route rested: the coordinator rested it"
)

NRouteWoken is the happened note of a rest the coordinator ended (routes wake), and NRouteRestedByCoordinator of one the coordinator began (routes rest).

const (
	RouteRestWindow = 10
	RouteRestAfter  = 3
	RouteRestFor    = 30 * time.Minute
)

A ROUTE RESTS ONLY ON A PROVIDER-TYPED FAILURE OR A COORDINATOR ACTION (the owner, 2026-10-10, through the seat: "this sounds like something the machine should not do. it should raise it to you as a thing to do, but not do it automatically."; tla/RouteRest.tla).

The tick counts the ended takes of each route over a sliding window, the last RouteRestWindow takes on it that ended after its last rest began, and when RouteRestAfter of them ended with a TRANSIENT provider failure (the provider's own line, class rate-limited, provider-5xx or timeout: a 429, a 5xx, the provider not answering) it rests the route for RouteRestFor (cause RestProvider): the rest is one line in the fleet table's property rule3_rest_<provider>, one property per provider however many of its routes rest, written in the deal's batch with a happened note to the coordinator naming the cards; the deal draws no work card (a first deal, a redeal or a rework's) on a resting route, and the rest ends by itself at its time. A take that ended with NO RESULT is the model's output on that card, never the provider's: it counts against the card's attempt and the route's ok%, and it never rests the route (rule 3 of 2026-10-02 rested on three of them; that rule is retired, and a rest it wrote holds no route: Retired). The rest is the sprint's, never config: nova-config's enabled stays the coordinator's.

const (
	NRouteRested    = "a route rested: its provider failed its takes"
	NProviderRested = "a provider rested: its funds or its key"
)

NRouteRested is the happened note of a rest the tick wrote, to the coordinator, and NProviderRested the note of a provider's (provider_funds.go).

const (
	RestProvider    = "provider"
	RestCredit      = "out-of-credit"
	RestAuth        = "auth"
	RestCoordinator = "coordinator"
	RestNoResult    = "no-result"
	RestBalance     = "balance"
)

The causes of a rest: a route's transient provider failures (RestProvider: rate limit, 5xx, timeout); a provider out of credit (a take it refused for want of credit); a take it refused for its key; and the coordinator's word (RestCoordinator, routes rest). Only out of credit counts toward stopping the sprint. RestNoResult (rule 3's, retired) and RestBalance (a balance poll's, retired: a low balance is a judgment, never a rest) are read only to say a rest written before is Retired.

const (
	RuleBaseGate    = "base-gate"    // the lander's base tree gate, retried before a stream stops, and its streams resumed when a land pass finds it green (landgo.go, land_base.go)
	RuleBound       = "bound"        // a card reached its bound: a new attempt a tier up, heavy to a friend
	RuleBriefDefect = "brief-defect" // the same finding twice: the card marked a brief defect, held
	RuleConflict    = "conflict"     // a head the lander refused (a file conflict, its PATHS, the tree gate): returned, redone on the tip at flash, resumed; the same refusal twice a brief defect
	RuleFailed      = "failed"       // work came back failed or with no result: redealt, then a tier up
	RuleFriendTake  = "friend-take"  // a friend's work card past its bound that she has not started: taken back, dealt again (judgment_rules.go)
	RuleHoldNeed    = "hold-need"    // failed work whose report HOLDs naming a card that has not landed: waits for it, reworked once it lands (judgment_rules.go)
	RuleLate        = "late"         // a work card past its deadline: a wait once with progress; returned and redealt only once its holder stamped and went silent
	RuleReadLate    = "read-late"    // a read past its deadline: taken back and asked of another reader, once an attempt (judgment_rules.go)
	// RulePaths: a failed attempt whose report proposes PATHS (PATHS-PROPOSED): its widened
	// twin, or one judgment with the twin's command when a proposed file is shared
	// (paths_proposed.go). Not in RuleNames: nova-config's answer_rules_off enum
	// (config.AnswerRules, held equal to RuleNames) does not name it yet, so only run
	// --answer-rules=false turns it off.
	RulePaths = "paths"
)

The rules, by name: the names nova-config's answer_rules_off takes (config.AnswerRules).

const (
	// FieldRuleAnswer is the last rule answer on a card: "<rule>: <what> at <time>".
	FieldRuleAnswer = "rule_answer"
	// FieldRuleTier and FieldRuleFails are the failed rule's count on the primary: the tier
	// it counts on and the attempts that came back failed there.
	FieldRuleTier  = "rule_tier"
	FieldRuleFails = "rule_fails"
	// FieldRuleRedo is the attempt the conflict rule returned to be redone on the tip.
	FieldRuleRedo = "rule_redo"
	// FieldRuleRefused and FieldRuleRefusal are the last refusal the conflict rule returned
	// the card on: its way (RefusalWay) and the lander's words. A second refusal of the same
	// way is a brief defect.
	FieldRuleRefused = "rule_refused"
	FieldRuleRefusal = "rule_refusal"
	// FieldRuleWaited is the work card's generation the late rule waited on, once.
	FieldRuleWaited = "rule_waited"
	// FieldBriefDefect is the stamp the brief-defect rule marked the primary with.
	FieldBriefDefect = "brief_defect"
	// FieldProgress is a work card's last progress: the server's time of its holder's last
	// `progress` verb (Progress), which the member and the friend daemon send every
	// ProgressEvery while the child or the turn prints. The late rule's sign that a late card
	// is moving; a stamp from before the card's take is another holder's and counts as none.
	FieldProgress = "progress"
	// FieldConflictKind and FieldConflictPaths are a conflict stop's facts on the stream's
	// control card, as the lander reported them (MergeReq).
	FieldConflictKind  = "conflict_kind"
	FieldConflictPaths = "conflict_paths"
)

The fields the rules write.

const (
	// RuleAttemptCap is the attempts a card's work may come back failed on one tier before
	// the failed rule raises it a tier: the first is redealt on the next route, the second
	// goes up (cost rule 2: escalate on the second failure, not the third).
	RuleAttemptCap = 2
	// RuleProgressWindow is how recent a late card's progress is to count.
	RuleProgressWindow = 10 * time.Minute
	// ProgressEvery is how often a holder whose child or turn prints stamps progress on its
	// card: inside RuleProgressWindow with room for a stamp that is late or lost.
	ProgressEvery = 3 * time.Minute
	// RuleLateWait is the late rule's one wait.
	RuleLateWait = 30 * time.Minute
	// RuleSameFailureCards is how many cards failing the same way (their failure's class)
	// make the failure the fleet's, not the card's: the failed and bound rules leave each to a
	// mind rather than climb the ladder with every card (sameFailure).
	RuleSameFailureCards = 3
)

The rules' numbers.

const (
	RefusedConflict = "conflict" // the head does not merge: a file no ledger owns conflicts
	RefusedPaths    = "paths"    // the lander's checks: it changes files outside its PATHS (E12)
	RefusedChecks   = "checks"   // the lander's other checks: a stranded fragment (E4)
	RefusedGate     = "gate"     // the merged tree fails the tree gate
)

The ways a head is refused at its landing, as the lander says them (cmd/nova-sprint, land.go and landgo.go: mergeHead, checkCard, gateCard): the conflict rule's "the same way" (RefusalWay).

const (
	ActRework = "rework"                    // the next attempt, on the next route of its tier
	ActUp     = "rework on a tier up"       // the next attempt, pinned a tier up
	ActFriend = "rework as a friend's card" // the next attempt, a friend's (above heavy)
	ActWait   = "wait 30m"                  // the late card made progress: held once
	ActHold   = "hold"                      // the late card's holder has not had its own deadline yet, or never stamped progress
	ActRedeal = "return and redeal"         // the late card withdrawn, dealt again
	ActReturn = "return"                    // the conflict card back to review
	ActResume = "resume"                    // the stream again, its conflict card out
	ActMark   = "mark brief defect"         // the card marked, the judgment kept
	ActTake   = "take back and deal again"  // the friend's card she has not started withdrawn from her row, dealt to another
	ActAsk    = "ask another reader"        // the late read taken back, asked of another reader
	ActNeed   = "wait for the card"         // the HOLD's card has not landed: the judgment waits on it
	ActLeft   = "left"                      // the judgment needs a mind
	ActOff    = "off"                       // its rule is turned off
)

The acts of a rule answer.

const (
	PartRulePaths  = "rule paths"
	PartRuleReturn = "rule return"
	PartRuleResume = "rule resume"
	PartRuleRework = "rule rework"
	PartRuleLate   = "rule late"
	PartRuleBrief  = "rule brief"
)

The tick's rule parts, in the order they run: the conflict's return, its resume, a twin (read-broken, rules_read.go), every rework (failed, bound, read-broken, hold-need, the conflict's redo), the late cards, the friends' cards taken back, a late read asked of another reader, the HOLDs waiting on a card, the brief defects (judgment_rules.go). Each is a step of its own on a fresh read, so the conflict's three moves can all be made in one tick. With TickReq.AnswerRules false each is empty.

const (
	Work    = "work"
	Readers = "readers"
	Merge   = "merge"
	Fleet   = "fleet"
)

The four tables, by their logical names. A deployment prefixes each (Names).

const (
	Asked   = "asked"
	Reading = "reading"
	OK      = "ok"
	Broken  = "broken"
)

Readers table columns.

const (
	Queued   = "queued"
	Merged   = "merged"
	Stuck    = "stuck"
	CI       = "ci"
	StateCol = "state"
	// Cost is the work table's last column: a stream's cell is the sum
	// of its landed cards' totals, kept on the stream's control card (FieldCost) and
	// mirrored as the row's text; the footer is the sum over the streams.
	Cost     = "cost"
	Since    = "since"
	Returned = "returned"
	Ctl      = "ctl"
)

Merge table columns. since (hidden) is when the stream's state last changed, for the machine. returned (hidden) holds a primary sent back from merging, so that accepting it again moves it rather than creating it: the table layer never places a removed member again. ctl (hidden) holds the stream's control card, whose fields are the stream's state.

const (
	Done       = "done"
	OkPct      = "okpct"
	DoneOK     = "ok"
	DoneFailed = "failed"
	// DoneDefect (hidden) holds a member's work cards that ended on a brief defect
	// (brief_defect.go): in neither done nor ok%, so a brief no worker could do is never
	// the worker's failure.
	DoneDefect = "defect"
	Status     = "status"
	Active     = "active" // friends.active: how long ago her session last wrote a file
	Tokens     = "tokens" // friends.tokens: her cards' usage summed, compact or in dollars
	Load       = "load"
	Withdrawn  = "withdrawn"
)

Fleet table columns (ready and working are named as in the work table). withdrawn (hidden) holds a work card withdrawn because no member was up, so that the tick deals the same card again rather than cutting another: the table layer never places a removed member again. ok and failed (hidden) hold the member's finished work cards, finished ok and finished failed, and defect (hidden) those that ended on a brief defect, counted in neither. done and ok% are the table's own formulas over the ok and failed cells, computed at render and never written: done is sum(ok+failed), ok% (the column okpct) is pct(ok/ok+failed), and the footer pools ok% over the members. ctl (hidden) holds the member's control card: its status and its width (width.go), which the width column shows beside working.

const (
	StreamWaiting = "waiting"
	StreamMerging = "merging"
	StreamStopped = "stopped"
	StreamLanded  = "landed"
)

Stream states (the merge table's state column).

const (
	Up   = "up"
	Down = "down"
)

Member status.

const (
	SeatCheckServer    = "server"
	SeatCheckStore     = "store"
	SeatCheckLoop      = "loop"
	SeatCheckFleet     = "fleet"
	SeatCheckFriends   = "friends"
	SeatCheckReaders   = "readers"
	SeatCheckDashboard = "dashboard"
	SeatCheckBus       = "bus"
	SeatCheckInbox     = "inbox"
	SeatCheckQueue     = "queue"
	SeatCheckVersions  = "versions"
	SeatCheckPush      = "push"
)

The check names in order of output.

const (
	// PropDealtMax is the work table's property: the dealt bound, a duration.
	PropDealtMax = "dealt_max"
	// PropFriendIdle is the work table's property: how long a friend holding cards may
	// show no session activity before it is an alarm, a duration.
	PropFriendIdle = "friend_idle"
	// PropFriendStallAfter is the work table's property: how long a friend holding cards
	// may show neither session activity nor card progress before she is stalled, a duration.
	PropFriendStallAfter = "friend_stall_after"
	// PropFriendStallStep is the work table's property: the duration of each rung of
	// the friend stall ladder.
	PropFriendStallStep = "friend_stall_step"
	// PropReadTier is the work table's property: the sprint's read tier.
	PropReadTier = "read_tier"
	// FieldReadTier is a stream's control card's field: the stream's read tier,
	// over the sprint's.
	FieldReadTier = "read_tier"
	// FieldRelease is a stream's control card's field: the release the stream
	// belongs to (e.g. "v1.2.0"), set by stream set --release (docs/SPEC-SPRINT.md section 11).
	FieldRelease = "release"
	// FieldProse is a stream's control card's field: the globs (PATHS globs, comma
	// separated) of the files whose backquotes are their own, which the lander does not
	// read for a code span (land_repair.go); set by stream set --prose.
	FieldProse = "prose"
	// PropFleet and PropFriends are the work table's properties: the switches of the
	// fleet's work and the friends' work (the owner, 2026-10-06: "We should be able to
	// enable/disable fleet, enable/disable friends. default enabled."), SwitchOn or
	// SwitchOff, on when absent. Off, the deal hands that side no work card; reads flow.
	PropFleet   = "fleet"
	PropFriends = "friends"
	// SwitchOn and SwitchOff are a switch's words.
	SwitchOn  = "on"
	SwitchOff = "off"
	// PropFleetTiers and PropFriendsTiers are the work table's properties: the tiers each
	// side may take (the owner, 2026-10-06: "a setting for friends, what tiers they may
	// take, default to all. Same setting for the fleet."), comma joined in the ladder's
	// order, or TiersAll, all when absent. The deal hands a side only cards whose tier is
	// in its set, on top of each row's own tiers, work cards and read cards alike; a card
	// pinned to a model is no exception (the set is the owner's switch), and a frontier card
	// waits for the coordinator whatever the sets.
	PropFleetTiers   = "fleet_tiers"
	PropFriendsTiers = "friends_tiers"
	// PropReadsNeeded is the work table's property: how many readers' ok reads at its
	// head every card in review needs, whatever its tier (nova-sprint set --reads): "0",
	// "1" or "2"; absent or default, each card's own rule (ReadsNeeded). 0 asks no read:
	// a primary whose work finished LAND at its head is accepted on its own work.
	PropReadsNeeded = "reads_needed"
	// PropReworkPriority controls priority on the next attempt: fix (default), high or keep.
	PropReworkPriority = "rework_priority"
	ReworkKeep         = "keep"
	// TiersAll is the word of a side that may take every tier, the default.
	TiersAll = "all"
	// ReadTierDefault is the word that takes a read tier off: a stream's back to
	// the sprint's, the sprint's back to each card's own tier.
	ReadTierDefault = "default"
)

The sprint's settings, the coordinator's (`set`, `stream set`; nova-tools#5096 items 22 and 27): the dealt bound, how long a work card may wait dealt and never taken before it is a judgment, and the read tier, the tier a primary's reads draw their route from when it is stronger than the card's own. The sprint's are the work table's properties, the stream's a field of its control card; a clear starts the next epoch with neither, as it starts every property.

const (
	TidyFriends = "friends"
	TidyFleet   = "fleet"
	TidyRoutes  = "routes"
	TidyStreams = "streams"
)

The kinds a tidy names (--friends, --fleet, --routes, --streams; --all is the four).

const (
	FieldBaseGateRefused = "base_gate_refused"
	FieldBaseGateBase    = "base_gate_base"
	FieldBaseGateFirst   = "base_gate_first"
)

The base-gate count on a stream's control card (docs/SPEC-SPRINT.md section 8, land-base-gate-stops-stream): how many landings in a row were refused on the base's tree gate, the base they were refused on, and when the first was. A pass that merges, any other stop, a stop on the base and a resume clear it.

const (
	FieldDeadBase = "dead_base"
	FieldBaseSet  = "base_set"
)

FieldDeadBase is the base a merging card names that the lander found not on origin, on the primary; FieldBaseSet is the last re-point of its BASE (CardBase): old -> new, when, by whom.

const (
	FieldDecideBounce = "decide_bounce"
	FieldDecideReview = "decide_review"
)

A decide read's fields on its read card: the sprint row's two bars on p(defect) it is routed by (docs/SPEC-SPRINT.md section 6, the decide read; internal/decide, Bars).

const (
	FieldDecideGateFlaky       = "decide_gate_flaky"
	FieldDecideGatePreexisting = "decide_gate_preexisting"
)

A work card's gate decision fields: the sprint row's two bars on a failed gate's decisions (docs/SPEC-SPRINT.md section 5, the gate verdict; internal/decide, GateBars).

const (
	PropIdentical    = "identical"
	FieldIdentical   = "identical"
	IdenticalDefault = 2
)

PropIdentical is the work table's property holding the sprint's identical-finding bound, FieldIdentical a stream's control card field holding the stream's, over the sprint's; IdenticalDefault is the bound when neither is set. A value under 2 is no setting: one finding is never a repeat.

const (
	FieldLandedP     = "landed_p"     // the top class's p, three places
	FieldLandedClass = "landed_class" // the top class
	FieldLandedOp    = "landed_op"    // the score decision's id in the lander's record
)

The landed score's fields on a landed card.

const (
	DeadlineUnfinished = 2 * time.Hour    // a work card taken and not finished (a card dealt and never taken: the dealt bound, settings.go)
	DeadlineUnbegun    = 30 * time.Minute // a read card asked and not begun
	DeadlineUnreported = 2 * time.Hour    // a read card begun and not reported
	DeadlineMergeIdle  = 30 * time.Minute // a stream with cards to merge and no merge step
	// DeadlineJudgment is how long a judgment stays open, in running time,
	// before the tick marks it overdue; a review time the coordinator set
	// (wait) is the judgment's own due time instead.
	DeadlineJudgment = 10 * time.Minute
)

Deadlines, each against running time: time the machine was STOPPED does not count.

const (
	FieldProviderError = "provider_error"
	FieldProviderTake  = "provider_take_" // + the take's number, redeals + 1 when it ended
)

A take the provider failed ends like any take that ended without a finish: the card is withdrawn with FieldTakeEnded and dealt again, never judged as failed work (docs/SPEC-SPRINT.md, the work card's redeals; tla/CardContract.tla, ProviderFailure; tla/DirtyTick.tla, RedealsAreEndedTakes). The work card keeps the last failure's line (FieldProviderError, for the bound's judgment, cleared when it is dealt again) and a record of every take the provider failed (FieldProviderTake, ProviderTake: the record of that take, which `card` prints and the route stats count).

const (
	NResumed    = "stream resumed: the card it needed landed"
	NCannotAsk  = "cannot ask"
	NNoMember   = "no fleet member is up"
	NInvariant  = "an invariant is broken"
	NWorkLate   = "a work card is past its deadline"
	NReadLate   = "a read card is past its deadline"
	NMergeLate  = "a stream has had no merge step past its deadline"
	NBound      = "a card reached its bound"
	NStarving   = "the fleet is starving"  // ready under twice the width while a wave is held (heldWave)
	NOverloaded = "a member is overloaded" // three timeouts within the window (overload.go)

	NMachineStarted = "the machine started"
	NMachineStopped = "the machine stopped"
)

The tick's own notification types.

const (
	PartLevel      = "level"
	PartLevelReads = "level reads"
)

PartLevel and PartLevelReads are the tick start's parts: the fleet's and the readers' rebalance.

const (
	DoneCause = "done"
	DoneHint  = "to continue: add work, then nova-sprint start"
)

DoneCause is the cause the machine's record carries when the done part stopped it, and DoneHint what the coordinator does to go on.

const (
	NStoppedAssignments        = "STOPPED with unresolved assignments"
	NStoppedAssignmentsCleared = "STOP assignment condition cleared"
)

const (
	// NStopMemberDown is a fleet machine down, or never beaten, or held adopting past
	// StopAdoptAfter, that the coordinator did not hold: its width idles.
	NStopMemberDown = "a fleet member is down and the coordinator did not hold it"
	// NStopPinWaits is a ready card hard-pinned to a friend who is not up: it, and every
	// card that needs it, waits for her alone.
	NStopPinWaits = "a card pinned to one friend waits while she is not up"
	// NFriendStalled is the stall ladder's third rung (friend_stall.go): two wakes
	// unanswered. Its own type, kept by the pass while her rung stands at 3 or above, so
	// the tick's check does not close it in the tick that raised it (as it did as NStalled,
	// whose findings never name a friend).
	NFriendStalled = "a friend stalled: two wakes unanswered"
)

The stop judgments of the coordinator's pass.

const (
	// StopMemberAfter is how long a member must have been down, in running time, before
	// the pass raises it: the status transitions' dwell, so a beat that lapses and comes
	// back raises nothing.
	StopMemberAfter = StatusDwell
	// StopAdoptAfter is how long a member may be held adopting (fleet_back.go) before the
	// hold is a stop: an adoption is a play of minutes.
	StopAdoptAfter = 15 * time.Minute
	// BehindEscalateEvery is the running time between two levels of the judgments late on
	// the coordinator: a new level is a new judgment, whatever quieted the one before.
	BehindEscalateEvery = 3 * PassEvery
)

const (
	StopKindMemberDown    = "member-down"
	StopKindMemberAdopt   = "member-adopting"
	StopKindPinWaits      = "pin-waits"
	StopKindFriendStalled = "friend-stalled"
	StopKindFriendDown    = "friend-stall-down"
	StopKindRouteRest     = "route-rest"
	StopKindProviderRest  = "provider-rest"
	StopKindStreamStopped = "stream-stopped"
)

The kinds of stop, as LiveStops names them.

const (
	// NStopsDigest is the digest of the automatic stops still holding.
	NStopsDigest = "automatic stops still hold"
	// NStopsDigestClock is the digest's clock: an acknowledgement, never a judgment.
	NStopsDigestClock = "the automatic stops' digest"
	// StopsDigestOldest is how many of the oldest stops the digest names.
	StopsDigestOldest = 5
)

The re-push of the stops is one digest (cold reader B, PR 5548: forty live stops were forty "still holds" lines every ten minutes). A stop's first raise is its own judgment, pushed; after it, every PassEvery of running time while any stop judgment has gone that long without a push, the pass writes one happened note to the coordinator, NStopsDigest: how many stops hold by kind, the StopsDigestOldest oldest with their undo verbs, and `nova-sprint doctor` for the full list. The clock is an acknowledgement, NStopsDigestClock, its At the last digest's, closed and written again with each digest (shown in no inbox, as the empty-row clock). A stop acknowledged, or waited to a review time not reached, is left out.

const (
	// StreamWorking is the control state of a stream reopened past its stop.
	StreamWorking = "working"
	// StreamClosed is what where and streams show for a landed stream that still
	// has a card open. The control card stays landed until the stream reopens.
	StreamClosed = "closed"
	// FieldPushedUnreported is the sha of a batch pushed and not reported, on the
	// work card and on the merge card (the merge card is written at once; a work
	// field waits for the pump while the machine runs).
	FieldPushedUnreported = "pushed_unreported"
	FieldPushedHead       = "pushed_head"
	FieldPushedAttempt    = "pushed_attempt"
)

const (
	PropDevSyncAt        = "dev_sync_at"
	PropDevSyncSha       = "dev_sync_sha"
	PropDevSyncBaseLacks = "dev_sync_base_lacks"
	PropDevSyncDevLacks  = "dev_sync_dev_lacks"
)

The merge table's properties of the dev sync: the last sync (when, and the base's sha after it) and the drift the last cycle measured.

const (
	UnitInstalled = units.UnitInstalled
	UnitMissing   = units.UnitMissing
	UnitDifferent = units.UnitDifferent
)

const (
	AdjTests    = "the same package's tests"
	AdjTestdata = "the same package's testdata"
	AdjLedger   = "a ledger"
	AdjDocs     = "docs a class test reads"
	AdjNamed    = "the HOLD names it with its reason"
)

What makes a file outside PATHS adjacent to the change (WidenAdjacent).

const (
	// FieldWidth is the control card's field, and the fleet table's column,
	// holding the member's width.
	FieldWidth = "width"
	// DefaultWidth is the width of a member whose control card names none.
	DefaultWidth = 64
	// MaxWidth is the widest a member may be: a width over it is refused
	// before anything is written.
	MaxWidth = 1024
	// TickMaxDeal is the most cards one deal moves (T3, R6). The deal is one
	// plan; the store's apply cuts it into parts under the table layer's
	// entry bounds, so the deal refuses nothing by size under this.
	TickMaxDeal = 2000
)

A member is a fleet machine, and its width is the machine's child cap: the most work cards it runs at once. It holds up to DealAhead times its width, ready and working together: its width working and as many again ready behind them, so the sprint feeds the fleet at width and keeps it working at that width until done. The width is a field of the member's control card, set by init --members <m>:<n> and by fleet up <m> --width <n>, and shown in the fleet table's width column. The deal fills every member up to DealAhead times its width in one step, round the fleet (T3, R6), and the level, once at the start of every tick, moves ready cards from a member that cannot start them to one with free lanes, never past DealAhead times its width (T4, R7). The model is tla/SprintEvents.tla: PlanDeal's room (its Cap), which counts the ready cards of a member; the room here counts ready and working.

const ActTwinWider = "twin with PATHS widened"

ActTwinWider is the read-broken rule's act on a finding outside PATHS: the card twinned with its PATHS widened.

const ActWiden = "widen PATHS in place"

ActWiden is the widen rule's act.

const AdapterFolder = "folder"

AdapterFolder is the adapter of a harness with no deliver command (Claude Code's, and every harness whose nova-friend adapter is passive): the push loop writes each check and each pushed message as one file into the target directory, and the session watches that directory with a Monitor (FolderWatch) and answers the check's file with seat pong (FolderProve).

const Adopting = "adopting"

Adopting is the status of a member back from down, held while it adopts the release the coordinator's machine runs.

const AttributionRefusal = "attribution is never a finding (docs/SPEC-SPRINT.md); read --ok, or name the defect in the work"

AttributionRefusal is the remedy a `read --broken` whose finding is only about attribution is refused with (docs/SPEC-SPRINT.md, reader-ignores-attribution).

const BalancePollEvery = 10 * time.Minute

BalancePollEvery is how often the run loop reads the providers' balances.

const CheckMergeQueueP90 = "merge-queue-p90"

CheckMergeQueueP90 is the merge queue's check name.

const CheckNoStuckFriend = "no-stuck-friend"

CheckNoStuckFriend is the name of the first check.

const CollectReportChars = 600

CollectReportChars is how much of a failed report rides on its finish, as the daemon's outbox pass carries it.

const CostGapFloor = 1.0

CostGapFloor is the least gap in dollars that opens the judgment: just after midnight UTC a day's figures are cents, and a cent's difference is no gap to judge.

const CostGapOver = 0.05

CostGapOver is the share of the provider's figure a gap must pass to open the judgment.

const CostReconcileEvery = time.Hour

CostReconcileEvery is how often the run loop is to reconcile the providers' usage.

const CriticalBehind = 10

CriticalBehind is the weight at and above which a card is critical.

const CriticalByWeight = "critical (by weight, not yet ordered)"

CriticalByWeight is the key and the words where and the dashboard show a computed critical under (CriticalBehind or more cards behind it, no level set): it is shown and orders nothing yet, owed with the reference model (a level ordered by weight made the slow differential tier disagree: the ask's stream round, seed 1004).

const CycleWindow = 24 * time.Hour

CycleWindow is how far back a landing counts.

const DaemonPong = "asleep"

DaemonPong is the observation word for a pong her daemon answered and her session did not. It is the daemon's, kept on the row for it, and shown as down: the table's words are up, held and down (the owner, 2026-10-04 11:42 AM ET: "anything but up is down"; "sleeping = down").

const DealAhead = 2

DealAhead is how many widths of cards a member may hold, ready and working together: its width working and as many again ready behind them, so a lane that frees takes its next card at once and never waits for a tick. The member itself runs at most its width (the fleet row's, internal/member); the rest wait in its ready column.

const DealtMaxDefault = 3 * DeadlineUnfinished

DealtMaxDefault is the dealt bound when the coordinator set none: three times the deadline a taken card is held to. A member holds at most DealAhead times its width, ready and working, so a card at the back of its ready queue is taken within two take deadlines of a member that works; the third is the margin.

const DecisionRecut = "re-cut the brief"

DecisionRecut is the decision a brief defect asks for: the card is dropped and its brief cut again from the stream's generator, with what the worker found, as a new card; a redeal of the same brief would hold the same way (docs/SPEC-SPRINT.md section 1, a brief defect).

const DefaultReadLease = 10 * time.Minute

DefaultReadLease is how long an in-flight read's lease stands without renewal (10m).

const DefaultRollbackWindow = 15 * time.Minute

DefaultRollbackWindow is how long server switch watches for a failed land before the switch is considered permanent (docs/SPEC-SPRINT.md section 14; item 14).

const DevBranch = "dev"

DevBranch is the development branch, which promotion alone reaches.

const DrainVerb = "tick drain"

DrainVerb is the verb of the pump's drain step.

const DrainWidth = "0"

DrainWidth is the width cell of a member that drains: fleet up <m> --width 0 writes it, and it is no member of the deal, the level or a take by count (every room is DealAhead times 0) while its working cards finish, unlike fleet down, which deals them again elsewhere (the comfort list of 2026-10-03, item 5).

const FieldBase = "base"

FieldBase is a stream's control card field: the bases its cards name, from each brief's BASE: line, at admission.

const FieldBehind = "behind"

FieldBehind is the primary's weight as the tick last wrote it.

const FieldBench = "bench"

FieldBench is a primary's bench as its brief's BENCH line names it: the members' names, comma-separated, written by add and brief with the brief; absent on a card with none.

const FieldBriefAttempt = "brief_attempt"

FieldBriefAttempt is the primary's attempt when its brief was last replaced (Brief); absent, the brief is the one add gave it, at attempt 0.

const FieldBriefDefects = "brief_defects"

FieldBriefDefect (rules.go, the field the brief-defect rule stamps) also carries, on a work card and its primary, the reason a worker's HOLD named; FieldBriefDefects is a stream's count of them, on its control card, bumped by one in the finish that records each (a Bump, so two in one step add up).

const FieldCIRunStatus = "ci_run_status"

FieldCIRunStatus is the status of the last CI run reported on a primary, for its current head or another.

const FieldCost = "cost"

FieldCost is a landed primary's total cost (its total's charged figure, written as it lands) and a stream's control card's sum over its landed primaries: an exact decimal in USD, absent when nothing of it was priced. The work table's cost column shows the control card's (Cost; SyncMirrors).

const FieldFinderRead = "finder"

FieldFinderRead marks a read card asked of the finder out of turn (finderFirst): placed on purpose, the level leaves it where it is (levelReads).

const FieldFindingAttempt = "finding_attempt"

FieldFindingAttempt is the attempt whose broken reads' finding the primary's `finding` carries (Rework writes both: the attempt it sends back and what its readers found). A primary with a finding and no attempt recorded (admitted before this field) was reworked from the attempt before its current one.

const FieldFindingKeys = "finding_keys"

FieldFindingKeys is the primary's list of each attempt's finding key (FindingKey), one line an attempt ("attempt <n>: <key>"), appended by Rework beside FieldFindings and cut the same way: what the identical-finding bound reads back past the attempt before.

const FieldFindingReader = "finding_reader"

FieldFindingReader is the primary's field naming the reader whose finding its last rework sent back (the first broken read's reader at that attempt, in reader row order; Rework): the next attempt's first read is asked of them (Ask, finderFirst). Absent when the rework was of failed work.

const FieldFindings = "findings"

FieldFindings is the primary's list of what each attempt sent back found, one line an attempt ("attempt <n>: <the finding's first sentence>"), appended by Rework and cut to MaxCardTextBytes from the front (the latest kept): what the cap's judgment lists, and kept by the card the cap's default answer deals to a friend.

const FieldFriendDeadline = "friend_deadline"

FieldFriendDeadline is a friend's work card's working deadline in seconds, set when it is placed on her row (friendDealPass, FriendLevel: friendDeadline), as #5300 sets a machine's card's when it is dealt: absent while she has no ok attempt, and DeadlineUnfinished holds.

const FieldFriendsLeft = "friends_left"

FieldFriendsLeft is the friends a friend's work card has left, comma joined: each the level moved it off (FriendLevel), and the one the coordinator took it back from (FieldTakenFrom) once it is dealt again. Neither the deal nor the level places it on any of them again (docs/SPEC-SPRINT.md section 1, friend-deal-idle-lanes-first.w1), with one exception: a card withdrawn off a friend held or down that no other friend up may take is dealt back to a friend the level moved it off (never the one it was withdrawn or taken back from), rather than stranded ready (friendDealPass, withdrawnFrom).

const FieldGateWall = "gate_wall"

FieldGateWall is the measurement a card admitted pro by its gate's wall carries: `<median> n=<takes> over <bound>`.

const FieldHeld = "held"

FieldHeld is the stamp of a primary admitted held.

const FieldLease = "lease"

FieldLease is a read card's lease expiration timestamp.

const FieldLeveled = "leveled"

FieldLeveled marks a read card the level moved: the level moves it no more, so a read is never shuttled between readers tick after tick and the level never sticks on one card.

const FieldNeedsSet = "needs_set"

FieldNeedsSet is a sentinel's record of its needs re-pointed (sentinel set): "<before> -> <after> <stamp> by <who>", the last set.

const FieldNote = "note"

FieldNote is a card's note: the last rule answer that moved it, in the rule's words.

const FieldPassedHead = "passed_head"

FieldPassedHead is the head of the attempt a rework sent back when a reader had passed it (an ok read at it): what a next attempt that finds nothing new returns to review at.

const FieldPathsProposed = "paths_proposed"

FieldPathsProposed is the proposal the paths rule last answered on a primary: "attempt <n>: <glob,...>".

const FieldPriority = "priority"

FieldPriority is a primary's priority as set (by its brief's PRIORITY line or its stream's default at admission, or by the verb priority); absent is normal, or critical by weight.

const FieldPriorityDefault = "priority_default"

FieldPriorityDefault is a stream's control card's field: the level a card added to the stream later is given when its brief names none; absent is normal.

const FieldReadCard = "read_card"

FieldReadCard marks a read card the deal cut (read_cards.go), "1": a friend's read asked before read cards has none (its inbox job is its card id: Packet.ReadJob).

const FieldReadTake = "read_take_"

FieldReadTake is the record of one run of a read card that ended without a verdict (read --return), keyed by the run's number, 1 for the first, kept on the read card beside its usage (the run that gave the verdict); the producer's record of each run is on the primary (FieldCostRecord), keyed by the same number.

const FieldReadTierReason = "read_tier_reason"

FieldReadTierReason is a stream's control card's field: why its read tier was last set (`stream set --read-tier <t> --reason <why>`), beside FieldReadTier.

const FieldReadsNeeded = "reads_needed"

FieldReadsNeeded is the primary's field the accept writes when it accepted the card on the sprint's count (set --reads) rather than its tier's rule (ReadsNeeded): that count, so a card past review is held to the count it was accepted on.

const FieldRebalancedFrom = "rebalanced_from"

FieldRebalancedFrom is the rows a work card was rebalanced off, comma joined: the rebalance never places it on one of them again.

const FieldRelinked = "relinked"

FieldRelinked is a card's record of its needs re-pointed to a twin: "<old,...> -> <new> <stamp> by <who>", the last relink.

const FieldReplaces = "replaces"

FieldReplaces is a twin's record of the ids it replaced (add --replaces, recut): its lineage, as the old card's reason "replaced by <new>" is the other end of it.

const FieldRepo = "repo"

FieldRepo is a stream's control card field: the repositories its cards name, in the order their briefs name them (docs/SPEC-SPRINT.md section 11, the streams verb).

const FieldReported = "reported"

FieldReported is when a work card's report was written, as the transport knew it (a friend's REPORT.md: FinishReq.Reported), no later than its finish.

const FieldReturned = "returned"

FieldReturned is the stamp on a read card handed back with no verdict, until the ask asks it again.

const FieldReturnedAttempt = "returned_attempt"

FieldReturnedAttempt is the primary's attempt when the coordinator last returned it to review (return): at that attempt the pump does not accept it, and the judgment "returned to review" decides it.

const FieldRules = "rules"

FieldRules is a primary's rules by reference (nova-tools#5174 rule 6): the base name of the held rules file (fleet/child-rules*.txt) the member injects into its brief at stage time, written by add (and brief) with the brief it was held to, absent when the brief carries its own rules. It is the card's, so no later add changes what an earlier card's child reads.

const FieldStagingTake = "staging_take_"

FieldStagingTake is the record of a launch its member refused at staging, keyed by the generation refused (ProviderTake's shape: the route, the member, when, the reason). A staging refusal spends none of the redeal bound: its own bound is the fleet, each member refusing an attempt's card at most once, the deal never placing it on a member that refused it (tla/CardContract.tla, StageRefused, Restage and StagingBound).

const FieldStaleReview = "stale_review"

FieldStaleReview is the stream control card's field wait sets on the stream's stale judgment: the inbox does not show the stream stale before it.

const FieldStarted = "started"

FieldStarted is the generation of a friend's work card she has started, set by her start receipt (friendStartSet) and by nothing else: a card working on her row whose FieldStarted is not its generation was moved there by no start of hers (her finish's next, a take-back's next, a take), and the tick puts it back ready (friendUnstartedWorking).

const FieldTakeEnded = "take_ended"

FieldTakeEnded is the work card's mark that a take of it ended without a finish and it was withdrawn (no member had room, or it is at its bound): the deal that places it again counts that take, and unsets the mark.

const FieldWaitingReader = "waiting_reader"

FieldWaitingReader is the primary's mark of the note: "<attempt> <since>", the attempt it waits at and when the tick first found it waiting. The ask that asks it clears it.

const FieldWho = "who"

FieldWho is a primary's worker as its brief's WHO line names it, written by add and brief with the brief: WhoFriend for any friend, FriendRow(<name>) for one; absent on a machine's card.

const FirstSeatGeneration uint64 = 1

FirstSeatGeneration is the generation of a seat no change has moved: the first init's coordinator holds it, with no seat record; the first accepted change takes 2, and so on. Nothing resets it but teardown.

const FlashGateBound = 15 * time.Minute

FlashGateBound is the longest measured gate wall a card is dealt flash with.

const FriendIdleDefault = 20 * time.Minute

FriendIdleDefault is how long a friend holding cards may show no file write under her working directory and outbox before it is an alarm (nova-sprint set --friend-idle).

const FriendLaneLive = 2 * time.Minute

FriendLaneLive is how old a friend's beat may be while the cards it names running are her live lanes: her daemon beats every FriendBeatEvery, so a beat this old is a daemon that stopped, not a lane.

const FriendLevelPerTick = 4

FriendLevelPerTick is the most cards the tick's level moves in one tick.

const FriendReadDeadline = 30 * time.Minute

FriendReadDeadline is how long the friend has, on the sprint's clock, to return the read: thirty minutes. It is not a wall clock.

const FriendReadyMax = 10 * time.Minute

FriendReadyMax is how long a work card may sit ready on a friend's row while she has a lane free before it is a judgment (a work card past its deadline, dealt and never taken): in batch mode the deal takes it into the lane, in one-shot mode her daemon or her session takes it (take --as friend.<name>), and a card neither took is no one's (tla/FriendReadyTake.tla, NeverStrandedSilently).

const FriendStallAfterDefault = 20 * time.Minute

FriendStallAfterDefault is how long a friend holding cards may show neither file write under her working directory nor card progress before the stall ladder begins.

const FriendStallStepDefault = 5 * time.Minute

FriendStallStepDefault is the duration between rungs of the friend stall ladder.

const FriendStartMaxDefault = 20 * time.Minute

FriendStartMaxDefault is the start bound when the coordinator set none.

const FriendSyncLabel = units.FriendSyncLabel

FriendSyncLabel is the friend sync loop's launchd label; its plist is FriendSyncLabel.plist.

const FriendSyncService = units.FriendSyncService

FriendSyncService is the friend sync loop's systemd user unit.

const Friends = "friends"

Friends is the friends table: one row per friend of nova-config's friend rows (the owner, 2026-10-02: "add a friends table, above fleet and below merge. friends | status for now. up/down/held"), with the fleet table's columns but load (the owner, 2026-10-02: "please give friends in the friends table the same ready, working, width, done, ok%, status that we have for machines, but no load, since they don't correspond to a machine (at the moment...)"). It is drawn by where from the friends' records (store/friends.go: the roster, each friend's job cards and her beat), never stored as a table: nothing in the four tables, the tick or an epoch holds it.

const FsckSeatAgreement = "seat-agreement"

FsckSeatAgreement is the check's name.

const FundsCause = "every provider is out of credit"

FundsCause is the cause the machine's record carries when the tick stopped it because every provider is out of credit, and the words the judgment, the machine line and a refused start say (the owner, 2026-10-03: "if all providers are out, then you stop the sprint.").

const GCEvery = time.Hour

GCEvery is how often gc runs on every machine.

const GCMaxAge = 48 * time.Hour

GCMaxAge is how old a bench directory, a lander worktree or a job no runner names is before gc removes it (--max-age): two days.

const GCProbeEvery = 5 * time.Minute

GCProbeEvery is how often the loop reads each machine's volume between its runs.

const GCProbeLine = `df -Pk "$HOME" "$HOME/nova-bench" "${NOVA_AI_ROOT:-$HOME/ai}" 2>/dev/null; true`

GCProbeLine is the remote line that reads a machine's volumes between its runs: df -P of the home, the bench root and the AI root (those that exist).

const GCReportGrace = time.Hour

GCReportGrace is how old a report or a read's result is before gc takes a job or a read whose lane no runner's log names: the daemon that wrote it records it in that time.

const GCVolumeAlarm = 80

GCVolumeAlarm is the use, in percent, of a machine's fullest volume at which gc runs on it before its hour is up.

const GCVolumeRetry = 10 * time.Minute

GCVolumeRetry is the least time between two runs a full volume starts.

const Held = "held"

Held is the status of a member the coordinator holds down.

const HeldByAdopt = "adopt"

HeldByAdopt is the hold mark (FieldHeldBy) of a member held adopting: the tick alone releases it, and a coordinator's hold or release takes it over.

const HowGiven = "given"

HowGiven is a load given on the command line rather than measured.

const LandRefusedFinding = "the landing refused its head: "

LandRefusedFinding begins the finding a landing refusal leaves on its card, the way of it after (RefusalWay): two refusals the same way are the same finding, and the brief's bound (AtBriefBound) stops the card at the second.

const LegacyPongGrace = time.Hour

LegacyPongGrace is how long after the sprint server starts a --pong that is a time (the beat of a daemon from before the nonces: her session's last answer as that daemon had it) still counts as it did before, the time itself her proof: the server is adopted first and every daemon within the grace, so the adoption puts no friend down at once. After it, a time is a beat with no proof.

const LineMove = "move"

LineMove is the kind of a card's change. A notification's line has the notification's kind (judgment, happened, decided, acknowledged); a note on a card, when there is one, will be a line of kind "note".

const LineQueued = "queued"

LineQueued is the kind of a change a step queued for the work table while the machine ran (queue.go): what it asked, which the next tick's pump applies and writes a move line of. A replay of the move lines passes it by.

const LoopSilence = 15 * time.Second

LoopSilence is how long the run loop goes unseen before DOWN (docs/SPEC-SPRINT.md).

const MachineActor = "machine"

MachineActor is who the tick's moves and notifications are recorded as.

const MaxCardTextBytes = 8 << 10

MaxCardTextBytes bounds each text field a card carries, the brief excepted (the store refuses a step that would write a longer one); a rework's own derived words (the finding, why and the fix it takes from a finding) are cut to it, never refused for it.

const MaxCause = 300

MaxCause is the longest cause a line carries: the cause is its own card's, and a step that moves many cards says so in a few words on each.

const MaxIDLen = 128

MaxIDLen is the longest identity ValidID takes.

const MaxListed = 50

MaxListed bounds the primaries a notification lists; Count carries the total.

const MaxLook = 5

MaxLook bounds the cards "look" lists; past it, the command that lists the whole group.

const MaxProviderErrorBytes = 200

MaxProviderErrorBytes bounds the line FieldProviderError keeps.

const MaxReadGen = 2

MaxReadGen is the most generations of one reader's read card at one attempt: the plain identity and .g1 to .g<MaxReadGen>, each a read the machine took back (spentBy). A reader whose read was taken back that often is not dealt it again at the attempt.

const MaxRecentLandings = 10000

MaxRecentLandings bounds the landings RecentLandings keeps: the newest. It is far above the landings of an hour at any width the fleet has; past it, the hour's count, and so the rate, reads low.

const MaxReconcileDays = 62

MaxReconcileDays bounds the days a provider's record keeps.

const MaxRedeals = 3

MaxRedeals is how many times one attempt's work card is dealt again after a take of it ended without a finish, its member down or away while the card was working (its redeals counter, which no take resets). A card that was ready, never taken, is dealt again and keeps its count: a card is retired for repeated failure at members, never for members flapping while it sat ready. A working card whose member goes down with its count at the bound stays withdrawn, and the bound's judgment names it (docs/SPEC-SPRINT.md section 2, the work card's redeals; tla/DirtyTick.tla RedealsAreEndedTakes and RedealBoundHolds).

const MaxTakes = 64

MaxTakes bounds the numbered records of one card a reader looks for.

const MaxTimerNote = 512

MaxTimerNote bounds the note text a timer carries.

const MemberDownAfter = 3 * 15 * time.Second

MemberDownAfter is how long a fleet member goes without a beat before DOWN.

const MergeQueueP90Default = 30 * time.Minute

MergeQueueP90Default is the bar on the merge queue's p90.

const MergeQueueWindowDefault = 24 * time.Hour

MergeQueueWindowDefault is how far back a merge spell counts: the last day, the same day the landings and the cycle-time breakdown read.

const NAllOutOfCredit = "every provider is out of credit"

NAllOutOfCredit is the tick's judgment when it stops the machine for FundsCause: one, while every enabled route rests for its provider's funds.

const NCostGap = "a provider's usage and the sprint's cost records disagree"

NCostGap is the judgment of a provider whose own count of a day's usage and the sprint's cost records of that day differ past the bound.

const NDeadBase = "a merging card names a base not on origin"

NDeadBase is the judgment of a merging card whose BASE is not on origin.

const NDevBehind = "dev is behind"

NDevBehind is the tick's judgment that dev is behind, one for the sprint.

const NFewReaders = "fewer than two readers up"

NFewReaders is the tick's judgment that fewer readers are up than a primary in review waiting to be asked needs (two for a pro card, one for a flash card; ReadsNeeded): the ask raises it once, and asks no absent reader.

const NFilesAlarm = "open files above the alarm"

NFilesAlarm is the judgment of a member whose open file descriptors are above its alarm bound.

const NFriendStall = "friend stall"

NFriendStall is the happened notification type for stall ladder climbing and clearing.

const NGivenBack = "a card taken back from a friend given back"

NGivenBack is the happened note of a card taken back from a friend given back to her.

const NNoRoute = "no route serves the tier"

NNoRoute is the tick's judgment of a tier no route serves, once per tier (its subject is the tier's, StreamSubject(TierSubject(tier))), closed when the tier is served or no card of it waits.

const NPathsWidened = "PATHS widened by rule"

NPathsWidened is the happened note, to the coordinator, naming the files a card's PATHS were widened by.

const NPrioritySet = "priority set"

NPrioritySet is the happened note that records a priority change on the card's timeline (log --card), with the actor and the reason.

const NProviderFunded = "a provider's routes serve again: its balance is back"

NProviderFunded is the happened note of a rest of a provider's funds the poll ended.

const NRaiseReadTier = "raise the read tier of the stream?"

NRaiseReadTier is the tick's judgment that a stream's read tier should rise, one per stream.

const NReadBranchMissing = "a read's branch is not on origin"

NReadBranchMissing is the judgment of a read whose branch origin does not hold when no branch of the work on origin holds its head either: written at the first such close, on the primary, naming the read card and the branch. While it is open at the primary's attempt the primary wants no read (ReadsWanted, readCardsWanted): the seat pushes the branch and acks it (the tick asks the read again), or reworks or drops the card.

const NReadMissingBranch = "a read named a branch not on origin"

NReadMissingBranch is the happened note of such a read, re-asked.

const NReadersBehind = "the readers are behind"

NReadersBehind is the tick's judgment that the readers are behind, one for the sprint.

const NReadyToMerge = "ready to merge"

NReadyToMerge is the notice the pump addresses to the coordinator once a tick in which it accepted primaries: a notice, not a decision ("accept is mechanical, but the merge step is not"), naming every primary accepted.

const NRebalanced = "a queued card rebalanced to an idle lane"

NRebalanced is the happened note of a queued card rebalanced to an idle lane.

const NRemindFailed = "a reminder could not be delivered"

NRemindFailed is the judgment written once for a person whose reminder cannot be delivered.

const NRuleAnswered = "answered by rule"

NRuleAnswered is the happened note of a move a rule made that no judgment's close says (a late card returned to be dealt again).

const NScoredLow = "landed work scored low"

NScoredLow is the judgment of a batch whose landed work scored at or above the bar.

const NStalled = "stalled"

NStalled is the judgment of a stall: something nothing holds.

const NStreamArchived = "streams archived"

NStreamArchived is the tick's word that it archived streams whose every card has landed (stream archive): information, each stream named once.

const NStreamPrioritySet = "stream priority set"

NStreamPrioritySet is the happened note that records a stream's default level changing, on the stream's timeline (log --stream; its control card's, log --card ctl-<s>), with the actor and the reason.

const NTickEnd = "tick end"

NTickEnd is the tick's end note: written once at the end of a tick that addressed the coordinator something, "judgments=N"; inbox --wait wakes on it, and the inbox does not list it.

const NTimer = "timer"

NTimer is the judgment a timer whose due time has come is raised as.

const NWaitingForReader = "waiting for a reader"

NWaitingForReader is the tick's note on a primary in review whose read it could not ask for want of a reader with room (a machine reader of its tier at its width, or a friend at or above its read tier at her room when no paid reader has room): a happened note, no decision, written once an attempt (FieldWaitingReader), and the read is asked the tick a reader frees. Review never holds a card with no read asked and no note: an ask refused for a reason the coordinator decides is a judgment (cannot ask, fewer than two readers up), and the rest wait with this note (docs/SPEC-SPRINT.md section 6, a card waiting for a reader).

const NoEligibleReader = "no eligible reader for "

NoEligibleReader opens the tick's one judgment for every primary of a tick the ask refused for want of readers (TickAsk): "no eligible reader for <ids>".

const NoProof = "beat with no proof"

NoProof is the word for a beat whose --pong proves nothing.

const NoReaderMayRead = "no reader up may read it"

NoReaderMayRead begins the wait of a primary no unit up may be dealt its read card: the read-card ask raises cannot ask on it (readCardsAskPart).

const NotMeasured = "not measured: the check ran in the server; run nova-sprint seat check"

NotMeasured is what the dashboard, bus and friend agents say when the check ran inside the server (Server.Self).

const NothingWaits = "nothing waits: the tick accepts every primary in review whose reads are all ok and tells the seat (ready to merge)"

NothingWaits is what accept --read-ok says when no primary in review has the ok reads it needs: the tick accepts them, so nothing waits on the verb.

const OverloadTimeouts = 3

OverloadTimeouts is how many timeouts within the window make a member overloaded.

const OverloadWindow = 15 * time.Minute

OverloadWindow is how far back the timeouts are counted.

const PartCapDeal = "cap deal"

PartCapDeal is the attempt cap's default answer, the pump's part before the deal (TickCapDeal, brief_bound.go): a card past its cap goes to a frontier or heavy friend with room before the deal could give it to a machine.

const PartDone = "done"

PartDone is the name of the tick's last part, the done part.

const PartDrain = "drain"

PartDrain is the name of the work pump's first part: the work table's queue applied in one update (Drain). It needs the queue, which the store reads with the part's step: it has no planner here.

const PartFriendStall = "friend-stall"

PartFriendStall is the friend stall ladder part (friend_stall.go).

const PartRebalance = "rebalance"

PartRebalance is the work table's part after the deal (TickTables).

const PartRetire = "retire gone streams"

PartRetire is the name of the tick's retirement part (TickRetireGone).

const PartRuleTwin = "rule twin"

PartRuleTwin is the tick part that twins the cards a rule answers ActTwinWider.

const PartRuleWiden = "rule widen"

PartRuleWiden is the tick part that widens the cards the widen rule answers.

const PreviewLen = 8

PreviewLen is how many ids a rendered list of ids shows before it is cut: the card, the inbox and the notices name the first eight and count the rest, as the inbox's group line does, so a card with a thousand needs is one short line and never every id.

const PrimaryField = "primary"

PrimaryField is the field of a card that names its primary: the read cards, the merge card and the work cards of the fleet's table carry it, and Table.Of finds them by it.

const PromoteAge = 30 * time.Minute

PromoteAge is how long the oldest landing since the last promotion may wait before dev is behind.

const PromoteCards = 25

PromoteCards is how many cards may land on the sprint branch before dev is behind.

const PropCostReconcilePrefix = "cost_reconcile_"

PropCostReconcilePrefix is the fleet table property prefix of a provider's reconciliation.

const PropFriendStartMax = "friend_start_max"

PropFriendStartMax is the work table's property: the start bound, how long a card dealt to a friend may wait ready on her row unstarted, while her beat names no job running, before the tick levels it to another friend, a duration.

const PropReadCards = "read_cards"

PropReadCards is the work table's property that turns read cards on: ReadCardsOnWord.

const PropReadsWindow = "reads_window"

PropReadsWindow is the table property holding the verdicts' ledger: one line a verdict, "<stamp>\t<reader>\t<verdict>\t<tier>\t<finding>", oldest first, at most MaxReadsWindowLines.

const PropStatusSeen = "status_seen"

PropStatusSeen is the fleet property that keeps every row's status as the transitions last saw it, one property for the whole fleet (a table holds at most ntable.LimitTableProps): for each row "<row>=<word>,<transition>,<daemon start>,<away since>,<flaps>,<flapping since>", times RFC3339 or "-", one after another with a blank between, in row order. Away since is when the row first left the recorded status (zero while it holds it); the flaps are the departures that came back inside the dwell since the last transition counted.

const PushCheckPrefix = "NOVA SPRINT PUSH CHECK "

PushCheckPrefix opens the check the push loop delivers: the session sees it as the first words of its turn.

const PushProofFilePrefix = "PROOF-"

PushProofFilePrefix names the file a check is written as by the folder adapter: <target>/PROOF-<nonce>.

const QuietPropPrefix = "quiet_"

QuietPropPrefix is the fleet table's property of a member's quiet: quiet_<member>.

const ReadCardDeadline = 60 * time.Minute

ReadCardDeadline is how long a read card is given from its start (its take; a friend's read dealt working, from its deal) before the deal retires it late, spending its reader, and deals the read to another. A read never started is never late: one left untouched in ready past the deal bound (DealtMax) is taken back spending no one (RetiredByUnstarted).

const ReadCardsOnWord = "on"

ReadCardsOnWord is the setting's on word; any other value is off.

const ReaderPrefix = "reader-"

ReaderPrefix names a reader for its machine: reader-<m> is the one reader on the fleet machine m, and it runs at m's width, the fleet row's, read with its queue every tick as the member on m reads its own (the owner, 2026-10-02: "The reader widths seem to be very ad-hoc, unlike the machine widths"; "why not just have as many readers as workers per-machine"). The readers table holds no width column: a reader's width is derived from its fleet row (ReaderWidth), `queue --as reader-<m>` carries m's fleet row's width, and a reader named for no row carries none and begins nothing.

const ReaderSpendWindow = time.Hour

ReaderSpendWindow is the recent window a reader's spend is also summed over: the last hour.

const ReaderTiers = "tiers"

ReaderTiers is the readers table's text column: the tiers that reader reads. An empty cell is the default: a fleet reader reads flash alone while the store holds routes (fleetReadsFlashOnly; the owner, 2026-10-06, "I'm ok with flash readers on fleet but not pro"), and a friend's or a bud's reader, which brings its own model, every tier. The ask counts a reader only for a primary whose read tier (readTierOf) it serves.

const ReaderTiersAll = "all"

ReaderTiersAll is the --tiers word for every tier, stored as the list of them.

const ReaderTiersDefault = "default"

ReaderTiersDefault is the word for an empty cell, as --tiers takes it and a view prints it.

const ReadersWindow = 10 * time.Minute

ReadersWindow is how long reads sit asked and not begun on readers up before the readers are behind.

const ReaskedMissingBranch = "re-asked: the read named a branch not on origin"

ReaskedMissingBranch begins the note's text and the card's reason.

const RedStreamPrefix = "promote-red-"

RedStreamPrefix is the stream a red promotion cuts its fix cards into, with the day: promote-red-<YYYY-MM-DD> (docs/SPEC-SPRINT.md section 11, promote).

const RedoFixText = "redo the same change on the current tip"

RedoFixText is the fix every redo applies to the conflicted attempt.

const RemindEvery = 5 * time.Minute

RemindEvery is the running time between two pushes to one person.

const RepeatDecision = "stop and look"

RepeatDecision is added to a judgment for a primary that came back a second time for the same cause.

const RepriceKey = "cost reprice"

RepriceKey is the key of the step's log lines, one per route.

const RetiredByCoordinator = "coordinator"

RetiredByCoordinator is a read card's retired_by when the coordinator took the read back and asked another reader instead (ask --instead).

const RetiredByHold = "hold"

RetiredByHold is a read card's retired_by when the coordinator's hold --return took it back from its reader.

const RetiredByLapsed = "lapsed"

RetiredByLapsed is a read card's retired_by when its lease lapsed and it was taken back on restart.

const RetiredByLevel = "level"

RetiredByLevel is a read card's retired_by when the tick's level moved its read, asked and not begun, to another reader (levelReads).

const RetiredByMissingBranch = "branch-missing"

RetiredByMissingBranch is the retired_by of a read whose broken verdict named a branch origin does not hold: retired with no verdict and asked again.

const RetiredByReconcile = "friend reconcile"

RetiredByReconcile is the retired_by of a friend's work card friend reconcile returned.

const RetiredPrefix = "retired with its card: "

RetiredPrefix opens the decided note of a judgment retired with its card.

const ReworkOnAHigherTier = "rework with a fix on a higher tier"

ReworkOnAHigherTier is the bound's rework when the attempt before also ended at its bound on the card's tier (failure.go, reworkAtTheSameBound): Rework takes it only with --tier naming a tier above (boundDecisions).

const RoleReader = "reader"

RoleReader is the role a friend's nova-config row names to be dealt read cards; a machine reads when its reader row (reader-<m>) is on the readers table, the machine's reader identity, whose tiers cell names the tiers it reads (reader set --tiers).

const RuleConflictFix = "redo the same change on the current tip"

RuleConflictFix is the conflict rule's fix: the attempt's change made again where the stream is now.

const RuleReadBroken = "read-broken"

RuleReadBroken is the read-broken rule's name. run --answer-rules=false turns it off with every rule; the sprint's answer_rules_off naming it turns it off alone (RuleOff), though RuleNames and nova-config's enum (config.AnswerRules) do not list it yet.

const RuleReadTier = "read-tier"

RuleReadTier is the read tier rule: a stream's read tier is kept unless two substantive findings disagree (a reader's ok and another's broken with a finding, on one attempt at the stream's read tier), when it is raised; the question is never asked. A sprint row that turns it off (answer_rules_off) asks it again.

const RuleWiden = "widen"

RuleWiden is the widen rule's name; the sprint's answer_rules_off naming it turns it off alone (RuleOff), and run --answer-rules=false with every rule.

const ScriptReadPrefix = member.ScriptReadPrefix

ScriptReadPrefix begins the finding of an ok read a script reader gave: the reader ran the card's SCRIPT program at the attempt's start commit and its diff was the head's, byte for byte (docs/SPEC-SPRINT.md, the script read; member.ScriptVerifier). It is the member's own constant, so the finding a reader writes is the one counted here.

const SeatCheckToken = "MACHINERY"

SeatCheckToken is the first word of every line.

const SeatLabel = units.SeatLabel

SeatLabel is the push loop's launchd label; its plist is SeatLabel.plist.

const SeatService = units.SeatService

SeatService is the push loop's systemd user unit.

const Sentinel = "sentinel"

Sentinel is the kind of a card that marks a point in a stream: the tick never moves it from waiting or ready.

const SpendWindow = time.Hour

SpendWindow is the window the spend an hour is measured over: the last hour.

const SprintSubject = "sprint:done"

SprintSubject is the subject of a judgment about the whole sprint; no primary or stream id has a colon.

const StuckWindow = 4 * time.Hour

StuckWindow is how far back no friend may have been stuck.

const (
	// TickMaxMoves bounds the units one part of a tick applies; the rest are
	// due, and the next tick moves them. It is the deal's bound, TickMaxDeal
	// (width.go): one table-layer write's member candidates, which the step
	// builder cuts into parts under the table layer's entry bounds, so a
	// part plans every row that needs it in the one tick and never lags its
	// own work (every row of every
	// table moves every tick, never a row at a time).
	TickMaxMoves = TickMaxDeal
)

The bounds of one tick, and the one queue length the dealing keeps.

const TidyAgainAfter = time.Minute

TidyAgainAfter is how soon a tidy may follow the last: a second within it, by the recorded time to the nanosecond, is refused.

const TidyViewWindow = 30 * time.Minute

TidyViewWindow is the coordinator view's recent window (cmd/nova-sprint view.go, viewWindow): its finished-in-the-last-30m counts read the newest finishes.

const TwinReturnedFirst = "returned first: a merging card is taken off the merge queue before it is twinned"

TwinReturnedFirst is what a twin of a merging card says: the step returned it to review (Return), and the twin is made by the same verb's next step (cmd/nova-sprint twin).

const VerdictWords = 3

VerdictWords is how many words of the child's line a verdict's class keeps (FailureClass).

const WhoFriend = "friend"

WhoFriend is the who of a card dealt to any friend.

const WhoNone = "none"

WhoNone is the Selector's Who for a card that names no friend.

const WhyGone = "is on neither the work nor the merge table (stream remove took it off), so nothing can act on this"

WhyGone is the retirement's reason the tick gives for a stream the work and merge tables lack.

const WidenBlocked = "outside PATHS and not adjacent: "

WidenBlocked prefixes the text of a judgment the widen rule leaves: the files outside PATHS that are not adjacent to the change.

const WordNeverTaken = "dealt, never taken"

WordNeverTaken is the words of a work card late past the dealt bound.