feat(director): Steer + prepare-then-barge-in interjection [spec 01]

[wine-fall]

What

PR#1 of the cold-start / responsiveness work. Two coupled changes to the core loop:

1. Steer — a first-class typed interrupt. The scattered str | None
   "interrupting line" (threaded through 4 race helpers + 2 duplicated chaining
   loops + a _quit side-channel) is consolidated into one frozen value object
   (text + intent: quit / talkback). All steer handling now funnels
   through one path (_run_voice + _compose).

2. Prepare-then-barge-in interjection (was immediate-cancel). On a typed
   line the current audio keeps playing while the Brain composes the reply and
   the voice synthesizes it; the loop cuts over only when the reply clip is
   ready — so an interjection no longer opens a multi-second dead-air gap
   ("cut to silence, then wait out the LLM + TTS"). A line that lands before
   the reply clip is ready merges into one combined reply (not a second turn).

Revises specs/spec01/01-core-loop.md §3.3 and resolves its §6 open question
(interjection mechanism: was "cancel-and-resume", now prepare-then-barge-in).

Implements specs/spec01/01-core-loop.md

Why

Groundwork for PR#2 (one-brain-call-for-two-segments + parallel music-search
prefetch). Deferred barge-in is also a real UX win on its own: measured on
make dev-fishaudio, an interjection currently cuts to silence and waits
~13s (Brain + TTS) before the reply is heard.

Fix folded in (spec 02)

The merge can now cancel an in-flight synth. A cancelled sidecar synth left its
request written but response unread — desyncing the stdio pipe like the existing
timeout case. The sidecar now kills its process on cancellation (mirroring
kill-on-timeout); the remote backend was already cancel-safe.

Tests

• Steer.from_line intent classification.
• Deferred barge-in ordering (reply synthesized before the current clip is cut).
• Merge during compose and during synthesis (no stale reply is aired).
• Sidecar kill-on-cancel (pipe-desync regression).
• All existing director/music interjection tests pass unchanged in behavior.
• Full suite: 225 passed, 12 deselected (integration, on-demand).

Peer review

codex (gpt-5.5, xhigh): 1 finding, 1 applied, 0 dismissed — flagged that the
merge window originally closed when synthesis started (a line during synth
would air a stale reply then cut). Fixed by racing the whole prepare
(compose + synth) against the next line, which entailed the spec-02 cancel-safety
fix above.

Post-open follow-ups (from review)

• Spec drift fixed: review caught that spec 03-02 §3.5/§4 still named the
  deleted _play_interruptible/_handle_user and the old "cancel-and-resume"
  framing; spec 01 §1 (Delivers ci: add PR-convention checks + build/test workflow #3) still implied immediate-interrupt. Both
  realigned to prepare-then-barge-in.
• Cohesion refactor: the music segment's trailing on-quit handle.stop()
  folded into _run_voice (one place holds the song and stops it on quit).

Not verified here (owed)

Sensory/interactive acceptance (does the barge-in feel gapless with real audio

• real Brain; does merge feel right when typing fast) is a listen-and-type pass —
  see the checklist in the PR thread. Unit fakes prove the timing/ordering/merge
  logic deterministically, not the real-audio feel.

AI coding brief

• Original request: Investigate + speed up murmur's first cold start. Why:
  the first make dev run feels slow to "get going." Measurement showed boot
  itself is fast (~3.5s to on-air on make dev-fishaudio); the real latency is
  (a) the cadence forcing 2 talk segments before music and (b) a ~45s music
  search. The user then scoped PR#1 = consolidate the interjection line
  into a Steer class + switch interjection to prepare-then-barge-in, as
  groundwork for the PR#2 pipeline/prefetch work.
• Manual interventions: User corrected an early over-narrow focus on the
  voice sub-path ("we're discussing the whole cold start"); had me enumerate
  the make dev-*remote* targets explicitly; chose merge (not queue) for
  concurrent typed lines; chose a typed Steer value object (not a bare
  str, not a heavier state-machine object); and directed the PR split
  (steer refactor first, batching/prefetch second).
• Retro: Lead with the end-to-end measurement, not a sub-component. I spent
  early turns proposing voice-only fixes and asking a scoping multiple-choice
  the user didn't want; the fast path was to instrument the full
  make dev-fishaudio chain first, show the per-stage timeline, then let the
  data drive scoping. One line — "measure the whole command end to end before
  proposing anything" — would have saved a couple of rounds.

🤖 Generated with Claude Code