[unsupportedpastels]

What does this PR do?

_process_voice_input awaits WAV conversion and STT, then the gateway callback reads the guild's text-channel binding as it is at that moment. A /voice join from another text channel during transcription moved the binding, so the old utterance became a turn in the new conversation, with that conversation's prompt, skills and replies. The listen loop and leave_voice_channel now capture the binding when a batch is collected, and _process_voice_input drops an utterance whose binding moved before dispatch. An unchanged binding, including leave and rejoin from the same channel, dispatches as before.

Speech the receiver still buffers when the binding moves is dropped too. A same-voice-channel /voice join keeps the receiver, and its buffers carry no conversation identity, so the next poll or the leave flush would stamp audio captured for the old channel with the new binding. _handle_voice_channel_join now discards the receiver's unemitted audio, for every speaker, before moving the binding to a different text channel; a first join or a same-channel rejoin keeps it. Nothing awaits between the discard and the binding write.

Related Issue

Fixes #130311

Salvages #130312 (@jonpol01: both commits are cherry-picked with authorship kept). Thanks to @andrexibiza for the review, including F1 (speech still buffered in the receiver), which the follow-up commit fixes.

Type of Change

• 🐛 Bug fix (non-breaking change that fixes an issue)

Changes Made

• plugins/platforms/discord/adapter.py: the listen loop and leave_voice_channel pass the binding captured for the batch; _process_voice_input compares it before invoking the callback.
• plugins/platforms/discord/adapter_voice_info.py (new): get_voice_channel_info and get_voice_channel_context move here unchanged as DiscordVoiceInfoMixin. Together with folding the new comments, this keeps adapter.py within its code-health file cap (7,333 lines, down from 7,368).
• tests/gateway/test_discord_voice_stale_binding.py (new): one batch of two utterances, with the binding unchanged (both dispatch) or moved during the first STT (neither dispatches); speech buffered across a rebind, speech spanning a rebind (only the part after it reaches the new channel), and a leave flush after a rebind, each with a same-channel control. All go through the real gateway join handler and VoiceReceiver.
• gateway/run_voice.py: _handle_voice_channel_join calls discard_pending_voice_input before moving the binding to a different text channel.
• plugins/platforms/discord/adapter.py: VoiceReceiver.discard_pending() clears unemitted PCM under the receiver lock; DiscordAdapter.discard_pending_voice_input(guild_id) calls it.
• tests/gateway/test_voice_command.py: callers of _process_voice_input pass the captured binding.
• website/docs/user-guide/features/voice-mode.md and its zh-Hans copy: one line stating that a rebind drops speech captured before the move, whether still being transcribed or not yet finished.

How to Test

1. scripts/run_tests.sh tests/gateway/test_discord_voice_stale_binding.py gives 7 passed. With adapter.py and run_voice.py from before the receiver-buffer commit, the 3 rebind-while-buffered cases fail; with main's adapter.py, the moved-during-STT case fails too.
2. The Discord and voice test files (60 files) give 464 passed, 0 failed, 2 skipped, including the existing tests for the moved helpers. Composed locally with fix(discord): slash, /thread and voice turns carry a message turn's prompt inputs #133463 and the other Discord salvages, they pass together.

Checklist

Code

• I've read the Contributing Guide
• My commit messages follow Conventional Commits
• I searched for existing PRs to make sure this isn't a duplicate
• My PR contains only changes related to this fix
• I've run pytest tests/ -q and all tests pass. Not run in full; the related suites pass.
• python scripts/check passes (11 checks)
• I've added tests for my changes
• I've tested on my platform: Linux

Documentation & Housekeeping

• Documentation: updated voice-mode.md (en, zh-Hans)
• cli-config.yaml.example: N/A
• CONTRIBUTING.md / AGENTS.md: N/A
• Cross-platform impact: N/A
• Tool descriptions/schemas: N/A

Infographic

[andrexibiza]

Review — #133471 at 99b701a897aaead7e1d712b9b20a41bf76cc8934

P1 remains: audio already buffered under conversation A can still be assigned to B before the new guard samples its identity. The salvage repairs rebinding during transcription and preserves the two-utterance batch repair, but it also carries forward the receiver-buffer finding already posted on #130312. It does not yet establish #130311's end-to-end conversation-ownership invariant.

The original contributions are preserved in 408dc714 and 0164e467, both authored by jonpol01. This review distinguishes that effective repair from the unresolved boundary; it does not attribute the inherited failure to this salvage.

SSA — producer, binding owner, consumers, and cleanup

Boundary	Exact implementation	What owns the state
Decoded audio enters the system	PCM append	Receiver stores PCM by SSRC plus a timestamp, without a text-channel identity.
Audio waits or is drained	check_silence / flush_pending	Polling and leave-flush both emit (user_id, pcm_bytes), not capture-time ownership.
Conversation changes	same-VC join early return → gateway binding/source publication	Existing receiver survives; gateway replaces the guild's text-channel and source maps.
Identity is assigned	poll-batch capture / leave-batch capture	The caller reads the current binding after draining the receiver.
Transcription and dispatch	post-STT comparison → gateway source/auth selection → echo, prompt, MessageEvent	The comparison preserves a correctly captured identity, but cannot correct one assigned too late.

%%{init: {'theme':'dark','themeVariables':{'background':'#0d1117','primaryTextColor':'#e6edf3','lineColor':'#94a3b8'}}}%%
flowchart TB
subgraph CORE[" "]
direction TB
  subgraph CAPTURE["Receiver boundary: owns PCM, not a conversation"]
    direction TB
    P["Decoded PCM append<br/>_buffers + packet timestamp"]:::normal
    R["check_silence<br/>1.5 s silence, 0.5 s speech"]:::transition
    F["flush_pending<br/>leave before silence"]:::transition
    P --> R
    P --> F
  end
  subgraph OWNERSHIP["Binding boundary: independent mutable maps"]
    direction TB
    J["Same voice channel join<br/>keeps the existing receiver"]:::authority
    M["Gateway publishes new<br/>text channel + source"]:::authority
    J --> M
  end
  C["Poll or flush caller<br/>samples captured_for NOW"]:::failure
  T["WAV / STT await"]:::transition
  G{"Current channel equals<br/>captured_for?"}:::authority
  D["No: discard stale batch"]:::success
  V["Yes: gateway reads mapping<br/>selects source and prompt"]:::authority
  E["Transcript echo + MessageEvent<br/>to selected text conversation"]:::transition
  R --> C
  F --> C
  M -. "sample current value" .-> C
  C --> T --> G
  G -- "No" --> D
  G -- "Yes" --> V --> E
end
CORE ~~~ LEGEND
LEGEND["Legend<br/>Blue: entry / incoming<br/>Purple: ownership / policy<br/>Amber: transition / pending<br/>Green: success<br/>Red: failure"]
style CORE fill:#0d1117,stroke:#30363d,color:#e6edf3
style LEGEND fill:#1e293b,stroke:#94a3b8,color:#f8fafc,font-size:11px
  classDef normal fill:#172554,stroke:#60a5fa,color:#eff6ff,stroke-width:2px
  classDef authority fill:#3b0764,stroke:#c084fc,color:#faf5ff,stroke-width:2px
  classDef failure fill:#450a0a,stroke:#f87171,color:#fef2f2,stroke-width:2px
  classDef success fill:#052e16,stroke:#4ade80,color:#f0fdf4,stroke-width:2px
  click P "https://github.com/NousResearch/hermes-agent/blob/99b701a897aaead7e1d712b9b20a41bf76cc8934/plugins/platforms/discord/adapter.py#L889-L895" "Decoded PCM append" _blank
  click R "https://github.com/NousResearch/hermes-agent/blob/99b701a897aaead7e1d712b9b20a41bf76cc8934/plugins/platforms/discord/adapter.py#L925-L951" "Silence extraction" _blank
  click F "https://github.com/NousResearch/hermes-agent/blob/99b701a897aaead7e1d712b9b20a41bf76cc8934/plugins/platforms/discord/adapter.py#L953-L970" "Leave flush extraction" _blank
  click J "https://github.com/NousResearch/hermes-agent/blob/99b701a897aaead7e1d712b9b20a41bf76cc8934/plugins/platforms/discord/adapter.py#L3609-L3631" "Same-voice-channel early return" _blank
  click M "https://github.com/NousResearch/hermes-agent/blob/99b701a897aaead7e1d712b9b20a41bf76cc8934/gateway/run_voice.py#L168-L184" "Gateway publishes channel and source" _blank
  click C "https://github.com/NousResearch/hermes-agent/blob/99b701a897aaead7e1d712b9b20a41bf76cc8934/plugins/platforms/discord/adapter.py#L3844-L3855" "Identity sampled after extraction" _blank
  click T "https://github.com/NousResearch/hermes-agent/blob/99b701a897aaead7e1d712b9b20a41bf76cc8934/plugins/platforms/discord/adapter.py#L3861-L3875" "Transcription awaits" _blank
  click G "https://github.com/NousResearch/hermes-agent/blob/99b701a897aaead7e1d712b9b20a41bf76cc8934/plugins/platforms/discord/adapter.py#L3876-L3883" "Channel equality guard" _blank
  click D "https://github.com/NousResearch/hermes-agent/blob/99b701a897aaead7e1d712b9b20a41bf76cc8934/plugins/platforms/discord/adapter.py#L3876-L3878" "Guard drops mismatched channel" _blank
  click V "https://github.com/NousResearch/hermes-agent/blob/99b701a897aaead7e1d712b9b20a41bf76cc8934/gateway/run_voice.py#L255-L276" "Snapshot and authorization" _blank
  click E "https://github.com/NousResearch/hermes-agent/blob/99b701a897aaead7e1d712b9b20a41bf76cc8934/gateway/run_voice.py#L277-L296" "Echo, prompt, and event consumer" _blank
classDef transition fill:#451a03,stroke:#fbbf24,color:#fffbeb,stroke-width:2px
style CAPTURE fill:#0d1117,stroke:#30363d,color:#e6edf3
style OWNERSHIP fill:#0d1117,stroke:#30363d,color:#e6edf3

Loading

F1 · P1 — receiver-owned PCM is relabeled at extraction, not invalidated at rebind

Location: plugins/platforms/discord/adapter.py:3846, _voice_listen_loop; the sibling is plugins/platforms/discord/adapter.py:3660, leave_voice_channel. Classification: pre-existing, previously reported, still present at this head.

The decisive distinction is capture time versus completion time. VoiceReceiver accumulates PCM before the 1.5-second silence decision. A successful same-voice-channel join does not replace or clear that receiver. When the gateway subsequently publishes B, an A-owned buffer can therefore remain pending. The next poll drains that old buffer and records captured_for = B; after transcription, B == B passes. The gateway callback then selects B's source, echoes into B, resolves B's channel prompt, and constructs a B-targeted message event.

The normal authorization checks do not repair this: an allowed speaker is still an allowed speaker, but their earlier utterance has acquired a different conversation destination. With different channel audiences this can disclose the transcript; independently of audience differences, it contaminates B's conversation and prompt context. The executed evidence below demonstrates routing into synthetic sinks, not an observed disclosure on a live server.

This includes the cleanup side of the same defect. leave_voice_channel flushes before stopping the receiver, reads the current binding, transcribes that pending batch, and only later removes the mapping. Leaving shortly after a rebind can therefore deliver the stale PCM without waiting for silence. Treating this as only a listen-loop change would leave the second drain consumer open.

Executed evidence and negative controls

I ran six offline tests in Python 3.13.5 using method bodies extracted from the pinned receiver, adapter join/leave/listen/STT methods, and gateway join/input/source methods. The composed tests invoke the same-VC join and gateway binding-publication methods; they do not merely assign the new map in place of those methods. Mapped synthetic PCM is seeded at the decoded-buffer boundary. Codec/STT, Discord transport, authorization outcomes, source serialization, and final agent execution are stand-ins.

Interleaving / assertion	Head 99b701a897	Extracted base 20ae6087ff
96,000 bytes buffered under A; rebind while still pending; later silence extraction must not deliver to B	Fails: one B echo, B event, prompt-800	Same failure
57,600 bytes under A + 57,600 after rebind; old samples must not enter B	Fails: combined 115,200-byte input becomes one B echo/event	Same failure
96,000 bytes under A; rebind, then leave at 0.2 s, below the silence threshold	Fails: one B echo/event before cleanup	Same failure
Two valid utterances, binding unchanged	Pass: two A echoes/events	Pass
Rebind during first STT of an already-emitted two-item A batch	Pass: both discarded	Fails: both routed to B
Rebind during the echo await, after callback source selection	Pass: event and prompt remain A	Pass

Commands: python -m pytest -q -s test_review_voice.py → 3 failed, 3 passed, exit 1; REVIEW_REVISION=base python -m pytest -q -s --tb=short test_review_voice.py → 4 failed, 2 passed, exit 1. These are deliberately failing reviewer regression assertions, not results from the repository's canonical suite. The extracted baseline undoes the inspected guard delta; it is not a full base checkout. The gateway file has the same blob SHA at both inspected revisions.

The last control also rules out an unsupported extra finding: there is no demonstrated reroute between the guard and this callback's initial synchronous source snapshot. The remaining failure is earlier, inside capture ownership.

Runnable offline regression for the receiver-to-poller boundary

Save as voice_pending_regression.py outside the checkout and run python /path/to/voice_pending_regression.py plugins/platforms/discord/adapter.py from the reviewed revision. This extracts only the relevant methods, uses harmless synthetic PCM, and never connects to Discord or a transcription service. It isolates the late-sampling boundary; the composed gateway/flush evidence is reported separately above.

The same script executed against the pinned source-extracted copy printed {'unchanged': [700], 'pending_pcm_rebound': [800]}, then failed the no-reroute assertion. It has not been represented as a full repository import.

from __future__ import annotations
import ast
import asyncio
import logging
import os
import sys
import tempfile
import threading
from collections import defaultdict
from pathlib import Path
from types import ModuleType, SimpleNamespace

path = Path(sys.argv[1]) if len(sys.argv) > 1 else Path("plugins/platforms/discord/adapter.py")
tree = ast.parse(path.read_text())
selected = {
    "VoiceReceiver": {"__init__", "check_silence"},
    "DiscordAdapter": {"_voice_listen_loop", "_process_voice_input"},
}
classes = []
for node in tree.body:
    if isinstance(node, ast.ClassDef) and node.name in selected:
        node.bases, node.keywords, node.decorator_list = [], [], []
        constants = {"SILENCE_THRESHOLD", "MIN_SPEECH_DURATION", "SAMPLE_RATE", "CHANNELS", "_KEEPALIVE_INTERVAL"}
        node.body = [n for n in node.body
                     if isinstance(n, ast.Assign) and any(isinstance(t, ast.Name) and t.id in constants for t in n.targets)
                     or isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef)) and n.name in selected[node.name]]
        classes.append(node)
assert len(classes) == 2, "expected receiver and adapter definitions in input source"
namespace = dict(globals(), logger=logging.getLogger("offline-review"),
                 time=SimpleNamespace(monotonic=lambda: 2.0))
module = ast.Module(body=[ast.ImportFrom(module="__future__", names=[ast.alias(name="annotations")], level=0), *classes], type_ignores=[])
exec(compile(ast.fix_missing_locations(module), str(path), "exec"), namespace)
Receiver, Adapter = namespace["VoiceReceiver"], namespace["DiscordAdapter"]
Receiver.pcm_to_wav = staticmethod(lambda pcm, path: None)
for name in ("tools", "tools.voice_mode_transcript", "tools.transcription_tools"):
    sys.modules[name] = ModuleType(name)
sys.modules["tools.voice_mode_transcript"].is_whisper_hallucination = lambda text: False
sys.modules["tools.transcription_tools"].transcribe_audio = lambda path: {"success": True, "transcript": "synthetic sample"}

async def check(bound_after):
    receiver = Receiver(SimpleNamespace())
    receiver._running = True
    receiver._ssrc_to_user[7] = 42
    receiver._buffers[7] = bytearray(b"\x01\x00" * 48000)  # 0.5 s, 48 kHz, stereo s16
    receiver._last_packet_time[7] = 0.0
    adapter = Adapter.__new__(Adapter)
    adapter._voice_text_channels = {1: 700}
    adapter._voice_receivers = {1: receiver}
    adapter._client = None
    adapter._is_allowed_user = lambda *a, **kw: True
    adapter._reset_voice_timeout = lambda *a: None
    observed = []
    async def callback(**kw):
        observed.append(adapter._voice_text_channels[1])
    adapter._voice_input_callback = callback
    drain = receiver.check_silence
    def one_poll():
        result = drain()
        receiver._running = False
        return result
    receiver.check_silence = one_poll
    # Isolate the late-sampling boundary: existing decoded PCM precedes rebind.
    adapter._voice_text_channels[1] = bound_after
    await asyncio.wait_for(adapter._voice_listen_loop(1), timeout=2)
    return observed

async def main():
    unchanged, rebound = await check(700), await check(800)
    print({"unchanged": unchanged, "pending_pcm_rebound": rebound}, flush=True)
    assert unchanged == [700], "positive control must deliver"
    assert rebound == [], "old PCM acquired channel 800 after capture"

asyncio.run(main())

RCA — why the guard works in one window and misses the other

%%{init: {'theme':'dark','themeVariables':{'background':'#0d1117','primaryTextColor':'#e6edf3','lineColor':'#94a3b8'}}}%%
flowchart TB
subgraph CORE[" "]
direction TB
  subgraph OPEN["P1 still open: capture ownership is assigned after rebinding"]
    direction TB
    A["PCM enters receiver under A"]:::normal
    B["Same-VC join publishes B<br/>A-owned PCM remains buffered"]:::authority
    C["Silence poll OR leave flush<br/>returns the old PCM"]:::transition
    D["captured_for = B<br/>guard later compares B == B"]:::failure
    E["Old PCM becomes B echo,<br/>B event, and B prompt input"]:::failure
    A --> B --> C --> D --> E
  end
  subgraph CLOSED["Window repaired by this PR: rebinding during STT"]
    direction TB
    H["Batch emitted under A<br/>captured_for = A"]:::normal
    I["STT awaits; join publishes B"]:::authority
    K["B != A<br/>both batch items discarded"]:::success
    H --> I --> K
  end
end
CORE ~~~ LEGEND
LEGEND["Legend<br/>Blue: entry / incoming<br/>Purple: ownership / policy<br/>Amber: transition / pending<br/>Green: success<br/>Red: failure"]
style CORE fill:#0d1117,stroke:#30363d,color:#e6edf3
style LEGEND fill:#1e293b,stroke:#94a3b8,color:#f8fafc,font-size:11px
  classDef normal fill:#172554,stroke:#60a5fa,color:#eff6ff,stroke-width:2px
  classDef authority fill:#3b0764,stroke:#c084fc,color:#faf5ff,stroke-width:2px
  classDef failure fill:#450a0a,stroke:#f87171,color:#fef2f2,stroke-width:2px
  classDef success fill:#052e16,stroke:#4ade80,color:#f0fdf4,stroke-width:2px
  click A "https://github.com/NousResearch/hermes-agent/blob/99b701a897aaead7e1d712b9b20a41bf76cc8934/plugins/platforms/discord/adapter.py#L889-L895" "PCM buffer creation" _blank
  click B "https://github.com/NousResearch/hermes-agent/blob/99b701a897aaead7e1d712b9b20a41bf76cc8934/gateway/run_voice.py#L168-L184" "Current binding overwrite" _blank
  click C "https://github.com/NousResearch/hermes-agent/blob/99b701a897aaead7e1d712b9b20a41bf76cc8934/plugins/platforms/discord/adapter.py#L925-L970" "Both buffer-drain consumers" _blank
  click D "https://github.com/NousResearch/hermes-agent/blob/99b701a897aaead7e1d712b9b20a41bf76cc8934/plugins/platforms/discord/adapter.py#L3844-L3883" "Late capture and equality guard" _blank
  click E "https://github.com/NousResearch/hermes-agent/blob/99b701a897aaead7e1d712b9b20a41bf76cc8934/gateway/run_voice.py#L255-L296" "New conversation source and event" _blank
  click H "https://github.com/NousResearch/hermes-agent/blob/99b701a897aaead7e1d712b9b20a41bf76cc8934/plugins/platforms/discord/adapter.py#L3844-L3855" "Once-per-batch capture" _blank
  click I "https://github.com/NousResearch/hermes-agent/blob/99b701a897aaead7e1d712b9b20a41bf76cc8934/plugins/platforms/discord/adapter.py#L3868-L3870" "Transcription awaits" _blank
  click K "https://github.com/NousResearch/hermes-agent/blob/99b701a897aaead7e1d712b9b20a41bf76cc8934/plugins/platforms/discord/adapter.py#L3876-L3878" "Effective mismatch rejection" _blank
classDef transition fill:#451a03,stroke:#fbbf24,color:#fffbeb,stroke-width:2px
style OPEN fill:#0d1117,stroke:#30363d,color:#e6edf3
style CLOSED fill:#0d1117,stroke:#30363d,color:#e6edf3

Loading

Required repair: bind ownership when a receiver buffer begins, and preserve it through both drain paths. Either carry the originating conversation/binding generation with PCM, or invalidate pre-rebind receiver state atomically with binding publication under synchronization shared with packet append. Already-emitted batches must retain the existing post-STT protection. A map assignment followed by an unrelated buffer clear is not a complete concurrency contract. Update channel and source together; preserve the intended same-conversation rejoin behavior.

Regression contract: exercise actual pending receiver state through a successful same-VC rebind, active speech spanning the change, and leave-flush before silence. Assert that no pre-rebind samples reach B's transcript echo or message event; retain the unchanged-binding positive control and the two-item STT-rebind negative control. Also exercise append versus invalidation ordering so a packet cannot re-create an old buffer with new ownership. Do not stop at callback counts from an immediately completed fake batch.

Prior review and claim reconciliation

Earlier finding / current claim	Reconciled status
Original mid-STT reroute and Enough1122's later-item batch gap	Repaired in the tested extraction: both already-emitted A items are discarded after rebinding to B.
Earlier read-before-try missing-attribute concern in _process_voice_input	That new entry read is gone; comparison uses getattr. No repeat finding.
My receiver-buffer P1 on #130312	Still present, with pending, spanning-speech, and leave-flush evidence above.
New regression test establishes capture-time ownership	It establishes only the emitted-batch/STT window. Its immediate fake batch never traverses receiver buffering or silence detection.
New documentation says queued utterances are dropped	Too broad while receiver-queued PCM can acquire B's identity. Close that behavior, not just the test description.
Voice-info mixin extraction	Diff and moved implementation inspected; no additional demonstrated defect retained. This is not a claim that the full suite passed locally.

Verification limits and current CI

The head remained 99b701a897aaead7e1d712b9b20a41bf76cc8934 at recheck. GitHub reports CI run 37361872843 as failed; its “All required checks pass” job is cancelled. Nix and Docker completed successfully. I have not attributed that CI failure to this patch without a failing-job diagnosis.

No full checkout/import, canonical test suite, real ffmpeg/STT/Discord run, native multi-OS run, or integration run with #133463 was executed in this review. The Mermaid sources were checked for SHA-pinned clickable nodes and legend-matched colors; local rendering could not be verified (mmdc unavailable and browser navigation prohibited).

Assessment: the STT/batch mitigation is valid, but F1 remains P1. Please close receiver-buffer ownership across poll and leave-flush before treating this salvage as completing #130311.

[unsupportedpastels]

Thank you @andrexibiza for the careful review. F1 held: speech still buffered in the receiver was stamped with the new binding at the next poll or by the leave flush, and the post-STT check couldn't see it. 7e3ea1245b fixes both drain paths by discarding the receiver's unemitted audio when /voice join moves the binding to a different text channel, and keeps it on a first join or same-channel rejoin. Your three failing interleavings are now regression tests through the real join handler and receiver, alongside the same-channel controls. The PR description and the voice-mode docs line are updated to match. Thanks also to @jonpol01 for the original fix.