/stop could not reach a running turn, and the reason was worse than a
missing cancel. go-telegram/bot runs one update worker that calls
handlers synchronously (defaultWorkers = 1, never overridden), and the
chat turn ran on it. While a turn streamed -- or sat in a shell tool --
the worker was blocked and /stop sat unread in the update channel until
the turn it was meant to kill had already finished.
Add gateway.Turns: a per-session serial lane that turns are submitted to
and that the event loop never waits on. The worker is free again in
microseconds, so /stop is serviced immediately; ordering comes from the
lane being serial rather than from the loop being blocked.
- Bare /stop cancels the running turn and clears the backlog behind it,
with no approval step. Approval guards destructive commands, and
gating the brake behind a confirmation defeats it. /stop <name> keeps
the existing process-termination behaviour and its approval.
- Cancellation propagates through the turn context, so it reaches the
model stream and any tool underneath -- a shell command built with
exec.CommandContext dies with the turn.
- Queues are unbounded and never shed. A dropped message is a silent
failure that surfaces later as an agent that ignored something.
- Turns are recovered per-lane: the channel's panic middleware wraps the
event-loop goroutine, which no longer runs the turn.
Also raise the chat step budget. It was hardcoded at 8 -- roughly one
read, one grep and two edits -- so turns hit the cap and stopped
mid-task with no indication they had been cut off. It is now
chat.max_steps, defaulting to 100. Interruption is /stop's job.