fix(channels): keep slash ButtonCallback actions dispatchable through debounce coalescing - #8117

The premise this patch is built on does not hold for the code path it patches, and as written it preempts the canonical dispatcher and changes two behaviours.

Blocking

1. dispatch_message already routes slash-prefixed button actions through the dispatcher.

The comment says "content_to_text wraps them in [Button: /agent X] which never matches the starts_with('/') check". content_to_text is not what extracts the text here. dispatch_message has its own inline let text = match &message.content at bridge.rs:4483, and its ButtonCallback arm at bridge.rs:4538-4551 is:

// If action starts with '/', treat it as a slash command directly.
// This allows interactive buttons (e.g. Approve/Reject on approval
// notifications) to trigger commands like /approve or /reject.
if action.starts_with('/') {
    action.clone()
} else { /* "[Button clicked: …]" */ }

text then reaches the dispatcher at bridge.rs:4605, which does the identical splitn(2, ' ') / is_channel_command / is_command_allowed / authorize_channel_user(ct_str, …, "chat") / handle_command / suppress_button_command_ack sequence this PR adds — including the RBAC check whose comment already names the button case ("reconstructed from a button", bridge.rs:4622-4627, the #6441 follow-up).

If you have a reproduction where a /agent X button does nothing, please attach it — the fix is likely somewhere else, see #3 below.

2. The new block short-circuits the /agents and /models inline-keyboard special cases.

Because it returns before let text = …, a button action of /agents or /models no longer reaches bridge.rs:4639-4710 and gets a flat text reply instead of an inline keyboard. Both other dispatch sites carry these special cases (bridge.rs:4230-4293 for typed commands, bridge.rs:4639-4710 for text/button slash commands); this makes a third site that does not, so a clicked command and a typed command diverge.

3. Policy-blocked commands now hard-refuse instead of reaching the agent.

Both existing sites treat "not allowed in this channel" as forward the text to the agent:

debug!(command = cmd, channel = ct_str,
       "Command blocked by channel policy — forwarding to agent as text");

(bridge.rs:4310-4314 and bridge.rs:4727-4733, with the explicit // Other slash commands (and blocked ones) pass through to the agent at 4735.)

The new branch instead sends "Command /{cmd} is not allowed in this channel." and returns, so the agent never sees the message. That is a deliberate policy decision made in two other places and reversed here without discussion.

4. 58 duplicated lines is the wrong shape for this even if a gap existed.

The comment itself states the goal — "must be re-injected as command text so the slash-command dispatcher at L4608+ picks them up" — and then re-implements the dispatcher rather than re-injecting. The auth check, the allow-list check, the ack suppression and the arg parsing now exist in three copies; the next change to any of them (a rate limit, an audit record, quoted-argument parsing) will land in one or two of the three. If a gap is found, normalize the content into text and fall through.

Where the real bug probably is

content_to_text's ButtonCallback arm (bridge.rs:1056) does render [Button: {action}] with no slash passthrough, and it feeds flush_debounced (bridge.rs:970-982, 1185). So a button press that arrives inside a debounce window is coalesced into [Button: /agent X] and dispatched as prose — the dispatcher never sees it. That matches the symptom, is one line rather than 58, and is testable without a live channel:

• content_to_text(&ButtonCallback { action: "/agent foo" }) returns /agent foo.
• A flush_debounced case where a single buffered ButtonCallback with a slash action produces dispatchable command text.

Either way this needs a test — bridge.rs has the fixtures for it already (see suppress_button_command_ack_* at bridge.rs:7429-7467 and the ButtonCallback constructions at 10164 / 10306) — and a changelog fragment (changelog.d/fixed/8117-....md).

This is the right fix. The 58-line dispatcher copy is gone, the one-line change is in content_to_text, and the diff is now +98/-2 with most of that being tests.

Verified rather than taken from the commit messages:

The fix is at the layer that had the bug. content_to_text's ButtonCallback arm now passes a slash-prefixed action through bare, so the debounced merge at bridge.rs:970-982 / :1195 builds dispatchable command text instead of [Button: /agent X]. The immediate path was never broken — dispatch_message has its own inline extraction — and this change leaves it untouched, so the two paths now agree instead of one preempting the other.

No behaviour was reversed this time. The /agents and /models inline-keyboard special cases and the "blocked commands forward to the agent" policy are both reached exactly as before, since nothing returns early any more.

The stale sanitizer_text_to_check doc was worth fixing and the fix is doc-only, correctly. The implementation already returned Some(action.clone()) on main (bridge.rs:1133) while the doc listed "ButtonCallback action" among the variants that return None — actively wrong, and wrong in the direction that matters, because that list is what the next person adding a text-bearing variant will use to classify it. Confirmed the arm is Some(action.clone()) on both main and this head, so there is no Block-mode gap here and this PR does not introduce or close one.

Breadth-scanned the other consumers. Besides the debounce sites, the only non-test caller is the message journal at bridge.rs:6835. A slash-action tap now journals as /agent foo rather than [Button: /agent foo], which is more faithful to what actually gets dispatched and matches the immediate path. Nothing else reads this.

Tests are the right three: the unit case on content_to_text, the lone-callback drain (the realistic single-tap path, which exercises drain's single-message fast path so dispatch_message still sees the ButtonCallback arm), and the two-message coalesce. test_content_to_text_button_callback with a non-slash approve action still asserts the placeholder, so the non-command shape is pinned too. Changelog fragment present and scripts/check-changelog-attribution.py passes.

Non-blocking observation

test_debouncer_button_callback_slash_actions_coalesce_as_command_text documents that two rapid taps merge to /agent foo\n/agent bar, which the dispatcher's splitn(2, ' ') will read as /agent with args foo\n/agent bar. That is pre-existing debounce behaviour for any two slash commands in one window, typed ones included, and not something this PR introduces — but the test now makes it visible, which is better than leaving it implicit. If it ever turns out to matter in practice it wants its own issue against the coalescer, not a change here.

Approving.