fix(display): stop ttyWriter.Done from hanging after context cancel

[glours]

What I did
Fixes #14114: Done() blocked forever once the render goroutine had already exited via ctx.Done() (e.g. after SIGTERM), since it sent on an unbuffered channel with nobody left to receive.

Closing the channel instead of sending never blocks, but a bare close() panics the moment ttyWriter runs a second Start/Done cycle on the same shared bus - which already happens today (run's nested create/start, publish's nested push, rm --stop's sequential stop then remove). Start now hands out a fresh, once-only-closable signal each cycle instead of a single shared channel, and run/publish stop opening a redundant nested bracket around calls already inside one.

Related issue
closes #14114
Supersedes #14115

(not mandatory) A picture of a cute animal, if possible in relation to what you did

[docker-agent]

Assessment: 🟡 NEEDS ATTENTION

The core fix is correct and well-structured: replacing the blocking channel send with a close()-based doneSignal (using sync.Once for idempotency) solves the deadlock, the per-cycle fresh signal design prevents double-close panics, and the switch to unexported create/start/push in run.go/publish.go correctly avoids double-bracketing.

Two medium-severity issues were found in the changed code.

Lower-confidence findings (not posted inline)

• [low] cmd/display/tty.go:199 — TOCTOU race: w.done can be replaced between w.print() and the mutex snapshot in Done() (confidence: 🟠 weak 52/100). Requires concurrent Start()+Done() on the same writer outside the sequential Run() wrapper — unlikely in practice but structurally present.

[codecov]

Codecov Report

❌ Patch coverage is 96.55172% with 1 line in your changes missing coverage. Please review.

Files with missing lines	Patch %	Lines
cmd/display/tty.go	96.00%	1 Missing ⚠️

📢 Thoughts on this report? Let us know!

[docker-agent]

Assessment: 🟢 APPROVE

The fix is well-designed and correct. The core changes — replacing the shared unbuffered done channel with a per-cycle doneSignal (wrapping sync.Once) and switching from a blocking send to a non-blocking close() — soundly fix the #14114 hang without introducing any new races or panics.

Key design points verified:

• sync.Once in doneSignal.close() prevents double-close panics across sequential and nested Start/Done cycles.
• Start() holds w.mtx while replacing w.done/w.ticker and captures them as local variables in the goroutine, so a later Start() reassigning the struct fields never affects the running goroutine's wait.
• Done() reads w.done and w.ticker under lock into locals before calling close(), so it always operates on the correct cycle's signal even if a concurrent Start() races in.
• Switching run.go and publish.go to the unexported create/start/push avoids the nested Start/Done bracket on the shared bus, with strings.ToLower preserved for parity with the public methods.
• The new tests (TestDoneAfterContextCancelDoesNotHang, TestNestedStartDoneDoesNotPanic, TestSequentialStartDoneEachGetFreshChannel, TestDoneBeforeStartDoesNotPanic) provide solid regression coverage, including goroutine-leak detection via goleak.VerifyNone.