A quiet spell: no breaks for the next few records

[robert-dean]

Status (2026-10-10)

The bug this was opened for is fixed. Removing a break from the running order leaves a removed
item in place rather than splicing it out (0ed2394), so the planner's walk counts from it and does
not plant a replacement a boundary later. DirectorService.collectRemoved fails the segment row
behind it with a reason, committedThrough no longer reads a cut as the committed head,
StationItemState gained the arm through the .ck, the SDK and the stored-row validator, and the
console draws a removed row grey. retireSegments in director/director.service.ts is now the one
retirement every edit that drops a break goes through.

A MOVED break was left alone on purpose: it is still in the order, so filling the gap behind it is
the planner answering a true order rather than forgetting an edit.

What is left is the quiet spell below, and the rotation.breaks-off-mid-air wart it settles. Neither
is built. deadair.station_air has no quiet column (only 0007 and 0046 touch it), there is no
/station/quiet, and BreakPlanner.plant still returns early on !rules.breaks while the breaks
already planted in the tail go on to air.

What it is

A suppression the operator sets, expressed in records rather than in items ("no breaks for the next
hour" or "the next N records"). Independent of the running order, so it survives an extend and a
regenerate, and it is what the listening session that found the removal bug actually wanted. Wants a
home: deadair.settings is wrong for something with an expiry, and the lineup's own
StationLineupRules overrides are right for "this lineup" but not for "for a while".

What it is for

The failure mode of rotation.breaks = false is not that it fails to work, it is that it has no
expiry. An operator turns it off for an album and the station never says its own name again until
they remember. Every property below follows from that one: the operator's standing preference is
left untouched, and the quiet ends by itself.

Records, not the wall clock

The ask offers both. What the audience gate rules out is the CLOCK: in audience mode a
station nobody is connected to is silent on purpose, so a wall-clock hour spent with no listeners
burns the whole suppression in silence and the operator comes back to a talking station. A count of
records only advances while somebody is hearing them, which is why it was chosen.

The grain argument this once rested on has moved, and it is worth knowing which way. Spacing was
counted in records when this was written, so records were also what everything else here was cut on.
It is now breakEveryMinutes, and the minutes it counts are AIRTIME (the durations of the items in
the order, never the wall clock), so the property that rules out an hour of silence is one both
units have, and the audience gate no longer decides between them. What is left is the reconciliation
this paragraph wanted to avoid: a suppression in records beside a spacing in minutes has to be
converted at the one place they meet, which is the walk that lifts the quiet. Whoever builds this
should count both in the same unit, and the planner's is the one with a setting behind it. The
console can still SAY either from the order's own durations, because saying it is presentation.

Where it lives: deadair.station_air

The two homes the note rules out are ruled out for good reasons, and this is what is left. That row
holds the one fact about the BROADCAST rather than about the programming or the station's
configuration, which is exactly what a quiet spell is. One integer column beside active
(breaks_quiet_records, 0 meaning not quiet), and StationAirRepository grows a writer for it
while get returns it.

Stored rather than held in the director's memory, by the argument that made active a column: an
app restarted mid-quiet must not come back talking.

deadair.settings is also the thing a quiet spell must not touch. Writing rotation.breaks to
express "quiet for ten records" would silently rewrite the standing preference it exists to leave
alone.

Where it decrements: DirectorService.remember

It already hangs off the rundown's confirmation that a record actually STARTED rather than off the
commit lead, and it already drops segments through isRenderItem. That is precisely the filter the
countdown needs, for the same reason: a break the station airs is not a record the listener is
counting. One set breaks_quiet_records = greatest(0, breaks_quiet_records - 1) on a path that
already writes a row per record, and it may fail as harmlessly as play history does.

What being quiet does

Three behaviours, and only the first is obvious.

1. plant returns early. One more clause beside if (!rules.breaks). Note that the interval
   itself is no longer part of that guard: breakEveryMinutes <= 0 now only stands the station's
   own spacing down inside slotsFor, and leaves the operator's clock bands planting on their own
   schedule. So a quiet spell has to be checked where breaks are turned off wholesale rather than
   where the floor's interval is read, or an anchored bulletin will air through it. Cheap, and by
   itself not enough.
2. It retires the breaks already planted in the tail. Planting runs to the end of the order, so
   at the moment quiet is asked for there are already three or four breaks laid out across the next
   hour. Without this, "no breaks for the next ten records" is not heard until the tail runs out,
   which is the same defect logged below against rotation.breaks toggled off mid-air. One
   mechanism settles both.
3. Nothing is written. Falls out of (2): ripen only offers what is still in the order.

The committed head is untouched throughout. A break already handed to the player airs, quiet or not,
for the same reason an operator cannot remove one.

The retirement SPLICES rather than marking removed, and the asymmetry with an operator's cut is
the load-bearing part. removed means "this slot is cut, do not refill it", and it works by
resetting the planner's count where it sits. A suppression is the opposite instruction: withdraw the
whole break structure now, and rebuild it from scratch when the quiet ends. Leave removed marks
across the tail and the walk counts from the last one when it lifts, so the station stays quiet for
an interval beyond what was asked and by an amount nobody can predict from the number they typed.
Splicing is safe here for the reason it was unsafe in the removal bug: nothing
replants while plant is gated, and when the gate opens the walk sees a clean tail. The segment rows
go through the same collection as a cut, and that shared piece now exists: retireSegments, which
every edit that drops a break already calls.

What it survives

An extend, a regenerate and a restart, deliberately: it is a fact about the room rather than about
the hour of programming that happened to be loaded when it was asked for. That is what makes it not
a lineup rule.

One open question, and the default is to survive: a stand-down followed by a fresh putOnAir.
Keeping it costs an operator who wanted a clean start one confused minute; dropping it costs the
operator who stopped the station to change playlists their quiet. Both are small, and the count
expires either way.

Surface

A command, like everything else that touches the order ({ kind: 'quiet'; records: number } through
DirectorMailbox), so it serialises against the commit pass rather than racing it. POST /station/quiet and DELETE /station/quiet in the .ck, and StationAir gaining quietRecords so
the console can draw it.

On the console, a control beside Stop offering something like 3 / 10 / rest of the order, and the
on-air header reading "quiet for the next 8 records" with a cancel. A station that has silently
stopped talking and a station that is quiet on purpose look identical otherwise, which is the same
class of problem the removed badge fixed.

Phases

1. The stored fact and the gate. Migration column, repository, mailbox command, plant reads it,
   remember decrements it. Works end to end; the quiet takes up to one interval to be heard,
   because the planted tail still airs.
2. Retire the planted tail, shared with rotation.breaks turned off mid-air, which stops being a
   documented wart in the same commit.
3. The surface: contract, air payload, console control and header.

Each is one commit and one sentence, and 1 is usable without 2.

Also worth settling with it

• rotation.breaks toggled off mid-air does not retire breaks already planted. The planner
  returns early, so nothing new goes in, but the ones already in the tail still air. That is
  defensible (they are programmed, and the head is committed anyway) but it is not what an operator
  who just switched breaks off expects to hear, and it is undocumented either way. Settled by
  phase 2 of the quiet spell, which needs the same withdrawal and should do both from one place
  rather than growing a second one later.
• Whether the console's delete should say what it did. A delete that answers "removed, and the
  station will not talk again until N records from now" is the whole of this bug's user-visible
  half.

[robert-dean]

Status check, 2026-09-22 (main at 23b983e)

Shape 1 is built (0ed2394): the removed state and retireSegments. Shape 2, the quiet spell, is not: no quietRecords or /station/quiet. Also still open: switching rotation.breaks off mid-air only stops new breaks being planned; ones already in the tail still air.

[robert-dean]

Closing: all three phases are built, in #768, and the rotation.breaks-off-mid-air wart is settled with them.

1. station_air.breaks_quiet_records (migration 0114) holds the count. The quiet director command sets it, and remember takes one off as each record starts.
2. Asking for quiet withdraws the station's own planted breaks (StationLineup.withdrawBreaks), splicing rather than marking removed, as argued here. Every commit pass with rotation.breaks off does the same, so a switch flipped mid-air is heard at once.
3. The surface is PUT and DELETE /director/air/quiet and StationAir.quietRecords. On the desk it offers the next 3, the next 10 or the rest of the order, then reads "Quiet for the next N records" with Talk again.

One departure from phase 1, on this discussion's own point about units. plant does not return early. Instead quiet.spell.ts turns the count into the boundary after the Nth record still to start, and slotsFor begins every walk of the station's own talk past it. Returning early would plant the first break after the quiet only when the count hit zero, a write and a render too late. Started past the boundary, the first break is planted and written ahead like any other. Somebody else's programme is still carried. A requested break is refused while quiet, with the count in the reason.

The open question is answered with the default: the quiet survives a stand-down and a fresh broadcast.