feat(buzz-acp): steering as the default mid-turn mention delivery

[tlongwell-block]

What

Delivers a new mid-turn mention to an agent without ending its turn, on agents that support it — and falls back cleanly to cancel+merge on agents that don't.

When an eligible author (the agent's owner, an allowlisted user, or a cryptographically-verified sibling bot) @mentions the agent while it's working, that message is folded into the live turn via a non-standard ACP steering extension — a mid-turn "inject and continue" method that today exists only as a vendor extension (_goose/unstable/session/steer). The agent keeps working and weaves the new message in; the turn is not cancelled or restarted. On any agent that doesn't implement the extension — detected behaviorally, never by capability flag — the same delivery path falls back to cancel + merge + steering-framing, which works on every ACP agent today.

This PR carries both halves of that delivery:

• Client side (buzz-acp): detect steer support, target the live run, route the mention through the steer extension with a clean fallback.
• Server side (buzz-agent): implement the steer method so buzz-agent's own agent can receive a mid-turn steer and fold it into its in-flight prompt.

Per Tyler's directive, both land here on #1160, not a follow-up.

Standardization intent

ACP has no standard mid-turn "inject and continue" primitive — the standard gives a client exactly one mid-turn signal, session/cancel, and it is terminal. The steering capability this PR uses originated as a non-standard extension in goose (_goose/unstable/session/steer). We think it should be a standard, and we intend to propose it as one.

With this PR, buzz-agent becomes the second known implementation of that extension — the first independent one outside goose. Two interoperating implementations of the same wire contract is exactly the evidence a standards proposal needs: it demonstrates the method is implementable, useful, and not goose-specific. Until that proposal lands, we treat the method as what it is — a non-standard extension — and detect it behaviorally rather than assuming it.

Why this shape

The design is: use the steer extension where an agent implements it, fall back to cancel+merge where it doesn't. Detection is behavioral (try-and-tolerate: method_not_found / invalid_params → fall back), not name- or capability-gated — the extension advertises no capability field, so a flag-based gate would be a lie. Because buzz-agent implements the identical wire contract goose does, a single client-side delivery path serves both agents — which is the point: the contract is shared, not vendor-locked.

Lanes

Lane A — client-side steer (buzz-acp). Steer-support detection, activeRunId parse from session/update _meta.goose.activeRunId (the extension's run-targeting field), the try-and-tolerate plumbing, and the AcpClient read-loop seam that routes a steer around the supervisor's cancel select! so the in-flight prompt future is never dropped. Landed as ff46007d.

Lane B — server-side steer (buzz-agent). Landed (528280bf). Implements the steer method end-to-end:

• Advertises a per-prompt activeRunId via params._meta.goose.activeRunId on session/update so steer-capable clients can target the live run.
• Validates steer requests against the extension's contract (non-empty prompt, active run present, expectedRunId matches the live run; otherwise invalid_params → client falls back).
• Queues accepted steers per session and drains them at each run-loop round boundary, appending as user turns. The turn continues; it is not restarted.
• Tests (tests/fake_llm.rs): steer folds into a live turn (end_turn, not cancelled; steered text reaches the provider); rejected on no active run, run-id mismatch, and empty prompt.

Baseline — cancel+merge default + steering framing. The original three commits (cbb2f787, a01df096, c4cd4c20): a MultipleEventHandling::Steer variant (now the default, was queue), ControlSignal::Steer with a cancel+merge requeue that stamps a CancelReason and renders steer-vs-interrupt framing. This is the fallback path for agents that don't implement the extension, and the behavioral floor.

Steer seam (AcpClient)

The seam routes a steer around the supervisor's cancel select! so the in-flight prompt future is never dropped:

1. mpsc::channel(1) + try_send; full/closed → fallback ControlSignal::Steer.
2. AcpClient.steer_rx: Option<Receiver> — installed at dispatch, take()d on prompt entry, dropped on scope exit; reuse/heartbeat tests pin the no-stale-receiver invariant.
3. TaskMeta { ..., steer_tx: Option<Sender<SteerRequest>> } — stored outside the moved OwnedAgent, same ownership pattern as control_tx.
4. Mode-gate fork (lib.rs): ControlSignal::Steer → pool.send_steer() + ack watcher; everything else → signal_in_flight_task.
5. Ack watcher forwards SteerAck { channel_id, event_id, result } to the main loop only (no concurrent pool/queue mutation): success → drop the withheld mention so it isn't re-delivered post-turn; failure → signal_in_flight_task(.., ControlSignal::Steer) (cancel+merge fallback, never Cancel, which would drop the batch); unknown-delivery-after-completion → leave queued, normal dispatch handles it.
6. Read loop reshape: select! over sleep_until / reader.next() / steer_rx.recv(), preserving pre-sleep idle classification. Steer write bounded by remaining hard deadline; idle resets only on a successful steer write, hard deadline stays absolute.

Eligibility / security

Author eligibility (owner ∪ allowlist ∪ verified siblings) is enforced upstream by the inbound author gate (author_allowed) — ineligible authors are dropped before the mode gate, so they can never steer. "Sibling" is a cryptographically-verified same-owner claim via the NIP-OA auth tag (is_owner_or_sibling), not a heuristic. The steer channel is an injection surface, so this authenticated definition is load-bearing.

Under the default respond-to=owner-only, the eligible set is owner ∪ siblings; allowlisted users are included only under --respond-to=allowlist. Widening the default gate would widen the inject surface for every deployment, so allowlist stays opt-in.

Behavior change

Flips the global default from queue to steer. On agents that implement the extension (today: goose, and now buzz-agent) the mention folds into the live turn; on other agents it falls back to cancel+merge with steering framing. Deliberate, per the "make steering the default" requirement.

Compatibility note

The steer extension is a recent capability: it shipped in goose 1.38.0. On older goose (and any agent that doesn't implement it), the client detects the absence behaviorally and falls back to cancel+merge with no lost events — slower path, identical correctness. A follow-up will tighten support detection and document the minimum version.

Files (9, buzz-acp + buzz-agent)

buzz-acp: config.rs (Steer variant + default flip + validation), pool.rs (ControlSignal::Steer requeue), queue.rs (CancelReason, steer-vs-interrupt framing), lib.rs (mode_gate_signal, steer detection + mode-gate fork), acp.rs (active_run_id parse + read-loop steer seam). buzz-agent: agent.rs, lib.rs, wire.rs (server-side steer method), tests/fake_llm.rs.

Tests

cargo test -p buzz-acp → 371/371 green under -D warnings (incl. the two read-loop steer tests). buzz-agent: steer folds-into-live-turn + three rejection cases. Steer-vs-interrupt framing, reason propagation, gate→signal mapping, config default + validation, queue→render e2e, and the OwnerOnly negative case (stranger dropped, owner+sibling admitted) all covered.

Live e2e: the full client→server steer round-trip was verified against a steer-capable agent (goose 1.38.0) over ACP — mid-turn steer accepted against the live activeRunId, steered content incorporated into the running turn, and the turn ended with EndTurn (a single turn, not a cancel + restart, and the mention was not requeued).

Reviewers

Dawn (framing wording), Perci (design correctness), Max (read-loop select! arm), Sami (Lane A owner).