A Live Countdown for a Parked Run
Turning a usage-limit wait from a stale corner note into a card that counts down to the resume time.
0 milestones 3 sprints
57m 28s total 15m 27s per sprint
26.4M tokens in 177k tokens out
$26.34 nominal cost
When an agent hits a provider usage limit mid-run, the run sleeps until the reset window opens and then tries again. This job made that wait visible as time, not just text: the engine now carries the wall-clock wake instant, the terminal state has a parked card for it, and the renderer counts down against that fixed instant in the host's local time.
The useful part of the cut is that each layer had its own proof surface. Data moved through the engine, wire, history, and headless paths before the terminal owned any card lifecycle; state then learned how a parked run starts and resolves before the renderer had to make it move.
How this walkthrough is structured
Feature
What did the run build and ship?
A usage-limit wait now appears as its own waiting card, fed by a durable wake instant and rendered with a local retry time plus a live remaining-time display.
Build
How did Gantry structure the work?
The job split a parked usage-limit wait into data, lifecycle, and rendering layers, and the run stayed green while clean review replans carried context between the first two boundaries.
Carry Wake Time
0 agents 15m 27s wall time 55.3k tokens out $7.78 nominal cost
The tree still has the wake instant on retry events, with encode and decode paths that tolerate older streams where the field is absent. The shared formatter turns a concrete instant into retry-at wording and remaining-time text, including the elapsed case that reads as resuming rather than negative time. Headless output also uses that data for a single line, so the terminal and line-oriented views share the same reset-wait vocabulary.
This sprint carried the non-visual foundation: a reset-wait already had a sleep duration, but later code needed the absolute instant it would wake. The brief kept the task narrow enough for a fresh agent by stopping at data plumbing, history and wire encoding, shared formatters, and the headless line. Its boundary was clean in the run facts, with no retry or failed gate; the later replan had a concrete contract to hand to the terminal work.
Dedicated Wait Card
0 agents 16m 56s wall time 60.8k tokens out $7.89 nominal cost
Terminal state now includes a waiting status and reset-wait metadata on cards. A usage-limit wait becomes a dedicated feed entry with its stage and sprint identity, repeated retry events update the open card, and real progress or stage completion settles it into a closed waited summary. Run stop paths close open waits as well, while ordinary overload retries still stay as notes on the running card.
This was the state-machine piece, deliberately separated from drawing so the card lifecycle could be asserted as pure application state. It took the wake instant from the first sprint and made usage-limit retry events create or update one keyed waiting card instead of mutating the running stage card. The run record shows another clean pass and a review replan after it, which left the renderer with a specific status and metadata shape to consume.
Live Countdown Render
0 agents 14m 10s wall time 47.3k tokens out $8.22 nominal cost
The renderer treats a live waiting card as a distinct card with the pause leading mark, the reset phrase, a retry-at line, and a remaining-time value recomputed each frame. A wait without a parseable wake instant renders without an invented countdown, and an elapsed live wait reads as resuming rather than counting below zero. The startup TUI path still captures the local offset before spawning the engine thread, and a reset-wait snapshot command remains in the tree for layout coverage.
The final sprint owned the visible behavior and the clock hazard the earlier pieces intentionally left out. Its brief scoped the work to rendering a waiting card, refreshing the render clock, capturing the local offset before worker threads exist, and adding a deterministic snapshot check. It did not need another replan or repair; by then the data and state contracts were already present, so the agent only had to connect rendering to them.