@openclaw/discord 2026.5.2 → 2026.5.3-beta.2

package/src/voice/manager.e2e.test.ts

@@ -1,928 +0,0 @@
-import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-import { ChannelType } from "../internal/discord.js";
-import { createVoiceCaptureState } from "./capture-state.js";
-import { createVoiceReceiveRecoveryState } from "./receive-recovery.js";
-
-const {
-  createConnectionMock,
-  getVoiceConnectionMock,
-  joinVoiceChannelMock,
-  entersStateMock,
-  createAudioPlayerMock,
-  resolveAgentRouteMock,
-  agentCommandMock,
-  transcribeAudioFileMock,
-  textToSpeechMock,
-} = vi.hoisted(() => {
-  type EventHandler = (...args: unknown[]) => unknown;
-  type MockConnection = {
-    destroy: ReturnType<typeof vi.fn>;
-    subscribe: ReturnType<typeof vi.fn>;
-    on: ReturnType<typeof vi.fn>;
-    off: ReturnType<typeof vi.fn>;
-    receiver: {
-      speaking: {
-        on: ReturnType<typeof vi.fn>;
-        off: ReturnType<typeof vi.fn>;
-      };
-      subscribe: ReturnType<typeof vi.fn>;
-    };
-    state: {
-      status: string;
-      networking: {
-        state: {
-          code: string;
-          dave: {
-            session: {
-              setPassthroughMode: ReturnType<typeof vi.fn>;
-            };
-          };
-        };
-      };
-    };
-    daveSetPassthroughMode: ReturnType<typeof vi.fn>;
-    handlers: Map<string, EventHandler>;
-  };
-
-  const createConnectionMock = (): MockConnection => {
-    const handlers = new Map<string, EventHandler>();
-    const daveSetPassthroughMode = vi.fn();
-    const connection: MockConnection = {
-      destroy: vi.fn(),
-      subscribe: vi.fn(),
-      on: vi.fn((event: string, handler: EventHandler) => {
-        handlers.set(event, handler);
-      }),
-      off: vi.fn(),
-      receiver: {
-        speaking: {
-          on: vi.fn(),
-          off: vi.fn(),
-        },
-        subscribe: vi.fn(() => ({
-          on: vi.fn(),
-          destroy: vi.fn(),
-          [Symbol.asyncIterator]: async function* () {},
-        })),
-      },
-      state: {
-        status: "ready",
-        networking: {
-          state: {
-            code: "networking-ready",
-            dave: {
-              session: {
-                setPassthroughMode: daveSetPassthroughMode,
-              },
-            },
-          },
-        },
-      },
-      daveSetPassthroughMode,
-      handlers,
-    };
-    return connection;
-  };
-
-  const getVoiceConnectionMock = vi.fn((): MockConnection | undefined => undefined);
-
-  return {
-    createConnectionMock,
-    getVoiceConnectionMock,
-    joinVoiceChannelMock: vi.fn(() => createConnectionMock()),
-    entersStateMock: vi.fn(async (_target?: unknown, _state?: string, _timeoutMs?: number) => {
-      return undefined;
-    }),
-    createAudioPlayerMock: vi.fn(() => ({
-      on: vi.fn(),
-      off: vi.fn(),
-      stop: vi.fn(),
-      play: vi.fn(),
-      state: { status: "idle" },
-    })),
-    resolveAgentRouteMock: vi.fn(() => ({ agentId: "agent-1", sessionKey: "discord:g1:c1" })),
-    agentCommandMock: vi.fn(async (_opts?: unknown, _runtime?: unknown) => ({ payloads: [] })),
-    transcribeAudioFileMock: vi.fn(async () => ({ text: "hello from voice" })),
-    textToSpeechMock: vi.fn(async () => ({ success: true, audioPath: "/tmp/voice.mp3" })),
-  };
-});
-
-vi.mock("./sdk-runtime.js", () => ({
-  loadDiscordVoiceSdk: () => ({
-    AudioPlayerStatus: { Playing: "playing", Idle: "idle" },
-    EndBehaviorType: { AfterSilence: "AfterSilence", Manual: "Manual" },
-    NetworkingStatusCode: { Ready: "networking-ready", Resuming: "networking-resuming" },
-    VoiceConnectionStatus: {
-      Ready: "ready",
-      Disconnected: "disconnected",
-      Destroyed: "destroyed",
-      Signalling: "signalling",
-      Connecting: "connecting",
-    },
-    createAudioPlayer: createAudioPlayerMock,
-    createAudioResource: vi.fn(),
-    entersState: entersStateMock,
-    getVoiceConnection: getVoiceConnectionMock,
-    joinVoiceChannel: joinVoiceChannelMock,
-  }),
-}));
-
-vi.mock("openclaw/plugin-sdk/routing", async () => {
-  const actual = await vi.importActual<typeof import("openclaw/plugin-sdk/routing")>(
-    "openclaw/plugin-sdk/routing",
-  );
-  return {
-    ...actual,
-    resolveAgentRoute: resolveAgentRouteMock,
-  };
-});
-
-vi.mock("openclaw/plugin-sdk/agent-runtime", async () => {
-  const actual = await vi.importActual<typeof import("openclaw/plugin-sdk/agent-runtime")>(
-    "openclaw/plugin-sdk/agent-runtime",
-  );
-  return {
-    ...actual,
-    agentCommandFromIngress: agentCommandMock,
-  };
-});
-
-vi.mock("../runtime.js", () => ({
-  getDiscordRuntime: () => ({
-    mediaUnderstanding: {
-      transcribeAudioFile: transcribeAudioFileMock,
-    },
-    tts: {
-      textToSpeech: textToSpeechMock,
-    },
-  }),
-}));
-
-let managerModule: typeof import("./manager.js");
-
-function createClient() {
-  return {
-    fetchChannel: vi.fn(async (channelId: string) => ({
-      id: channelId,
-      guildId: "g1",
-      guild: { id: "g1", name: "Guild One" },
-      type: ChannelType.GuildVoice,
-    })),
-    fetchGuild: vi.fn(async (guildId: string) => ({
-      id: guildId,
-      name: "Guild One",
-    })),
-    getPlugin: vi.fn(() => ({
-      getGatewayAdapterCreator: vi.fn(() => vi.fn()),
-    })),
-    fetchMember: vi.fn(),
-    fetchUser: vi.fn(),
-  };
-}
-
-function createRuntime() {
-  return {
-    log: vi.fn(),
-    error: vi.fn(),
-    exit: vi.fn(),
-  };
-}
-
-describe("DiscordVoiceManager", () => {
-  beforeAll(async () => {
-    managerModule = await import("./manager.js");
-  });
-
-  beforeEach(() => {
-    getVoiceConnectionMock.mockReset();
-    getVoiceConnectionMock.mockReturnValue(undefined);
-    joinVoiceChannelMock.mockReset();
-    joinVoiceChannelMock.mockImplementation(() => createConnectionMock());
-    entersStateMock.mockReset();
-    entersStateMock.mockResolvedValue(undefined);
-    createAudioPlayerMock.mockClear();
-    resolveAgentRouteMock.mockClear();
-    agentCommandMock.mockReset();
-    agentCommandMock.mockResolvedValue({ payloads: [] });
-    transcribeAudioFileMock.mockReset();
-    transcribeAudioFileMock.mockResolvedValue({ text: "hello from voice" });
-    textToSpeechMock.mockReset();
-    textToSpeechMock.mockResolvedValue({ success: true, audioPath: "/tmp/voice.mp3" });
-  });
-
-  const createManager = (
-    discordConfig: ConstructorParameters<
-      typeof managerModule.DiscordVoiceManager
-    >[0]["discordConfig"] = { voice: { enabled: true } },
-    clientOverride?: ReturnType<typeof createClient>,
-    cfgOverride: ConstructorParameters<typeof managerModule.DiscordVoiceManager>[0]["cfg"] = {},
-  ) =>
-    new managerModule.DiscordVoiceManager({
-      client: (clientOverride ?? createClient()) as never,
-      cfg: cfgOverride,
-      discordConfig,
-      accountId: "default",
-      runtime: createRuntime(),
-    });
-
-  const expectConnectedStatus = (
-    manager: InstanceType<typeof managerModule.DiscordVoiceManager>,
-    channelId: string,
-  ) => {
-    expect(manager.status()).toEqual([
-      {
-        ok: true,
-        message: `connected: guild g1 channel ${channelId}`,
-        guildId: "g1",
-        channelId,
-      },
-    ]);
-  };
-
-  const emitDecryptFailure = (manager: InstanceType<typeof managerModule.DiscordVoiceManager>) => {
-    const entry = (manager as unknown as { sessions: Map<string, unknown> }).sessions.get("g1");
-    expect(entry).toBeDefined();
-    (
-      manager as unknown as { handleReceiveError: (e: unknown, err: unknown) => void }
-    ).handleReceiveError(
-      entry,
-      new Error("Failed to decrypt: DecryptionFailed(UnencryptedWhenPassthroughDisabled)"),
-    );
-  };
-
-  it("rejects joins when Discord voice config is absent", async () => {
-    const manager = createManager({});
-
-    await expect(manager.join({ guildId: "g1", channelId: "1001" })).resolves.toMatchObject({
-      ok: false,
-      message: "Discord voice is disabled (channels.discord.voice.enabled).",
-    });
-
-    expect(joinVoiceChannelMock).not.toHaveBeenCalled();
-  });
-
-  type ProcessSegmentInvoker = {
-    processSegment: (params: {
-      entry: unknown;
-      wavPath: string;
-      userId: string;
-      durationSeconds: number;
-    }) => Promise<void>;
-  };
-
-  const processVoiceSegment = async (
-    manager: InstanceType<typeof managerModule.DiscordVoiceManager>,
-    userId: string,
-  ) =>
-    await (manager as unknown as ProcessSegmentInvoker).processSegment({
-      entry: {
-        guildId: "g1",
-        channelId: "1001",
-        route: { sessionKey: "discord:g1:1001", agentId: "agent-1" },
-        connection: createConnectionMock(),
-        player: createAudioPlayerMock(),
-        playbackQueue: Promise.resolve(),
-        processingQueue: Promise.resolve(),
-        capture: createVoiceCaptureState(),
-        receiveRecovery: createVoiceReceiveRecoveryState(),
-      },
-      wavPath: "/tmp/test.wav",
-      userId,
-      durationSeconds: 1.2,
-    });
-
-  it("keeps the new session when an old disconnected handler fires", async () => {
-    const oldConnection = createConnectionMock();
-    const newConnection = createConnectionMock();
-    joinVoiceChannelMock.mockReturnValueOnce(oldConnection).mockReturnValueOnce(newConnection);
-    entersStateMock.mockImplementation(async (target: unknown, status?: string) => {
-      if (target === oldConnection && (status === "signalling" || status === "connecting")) {
-        throw new Error("old disconnected");
-      }
-      return undefined;
-    });
-
-    const manager = createManager();
-
-    await manager.join({ guildId: "g1", channelId: "1001" });
-    await manager.join({ guildId: "g1", channelId: "1002" });
-
-    const oldDisconnected = oldConnection.handlers.get("disconnected");
-    expect(oldDisconnected).toBeTypeOf("function");
-    await oldDisconnected?.();
-
-    expectConnectedStatus(manager, "1002");
-  });
-
-  it("keeps the new session when an old destroyed handler fires", async () => {
-    const oldConnection = createConnectionMock();
-    const newConnection = createConnectionMock();
-    joinVoiceChannelMock.mockReturnValueOnce(oldConnection).mockReturnValueOnce(newConnection);
-
-    const manager = createManager();
-
-    await manager.join({ guildId: "g1", channelId: "1001" });
-    await manager.join({ guildId: "g1", channelId: "1002" });
-
-    const oldDestroyed = oldConnection.handlers.get("destroyed");
-    expect(oldDestroyed).toBeTypeOf("function");
-    oldDestroyed?.();
-
-    expectConnectedStatus(manager, "1002");
-  });
-
-  it("destroys stale tracked voice connections before joining", async () => {
-    const staleConnection = createConnectionMock();
-    const connection = createConnectionMock();
-    getVoiceConnectionMock.mockReturnValueOnce(staleConnection);
-    joinVoiceChannelMock.mockReturnValueOnce(connection);
-    const manager = createManager();
-
-    await manager.join({ guildId: "g1", channelId: "1001" });
-
-    expect(getVoiceConnectionMock).toHaveBeenCalledWith("g1");
-    expect(staleConnection.destroy).toHaveBeenCalledTimes(1);
-    expectConnectedStatus(manager, "1001");
-  });
-
-  it("does not throw when stale tracked voice connections are already destroyed", async () => {
-    const staleConnection = createConnectionMock();
-    staleConnection.state.status = "destroyed";
-    staleConnection.destroy.mockImplementation(() => {
-      throw new Error("Cannot destroy VoiceConnection - it has already been destroyed");
-    });
-    getVoiceConnectionMock.mockReturnValueOnce(staleConnection);
-    joinVoiceChannelMock.mockReturnValueOnce(createConnectionMock());
-    const manager = createManager();
-
-    await expect(manager.join({ guildId: "g1", channelId: "1001" })).resolves.toMatchObject({
-      ok: true,
-    });
-
-    expect(staleConnection.destroy).not.toHaveBeenCalled();
-  });
-
-  it("does not throw when leaving an already destroyed voice connection", async () => {
-    const connection = createConnectionMock();
-    connection.destroy.mockImplementation(() => {
-      throw new Error("Cannot destroy VoiceConnection - it has already been destroyed");
-    });
-    joinVoiceChannelMock.mockReturnValueOnce(connection);
-    const manager = createManager();
-
-    await manager.join({ guildId: "g1", channelId: "1001" });
-    connection.state.status = "destroyed";
-
-    await expect(manager.leave({ guildId: "g1" })).resolves.toMatchObject({ ok: true });
-    expect(connection.destroy).not.toHaveBeenCalled();
-  });
-
-  it("removes voice listeners on leave", async () => {
-    const connection = createConnectionMock();
-    joinVoiceChannelMock.mockReturnValueOnce(connection);
-    const manager = createManager();
-
-    await manager.join({ guildId: "g1", channelId: "1001" });
-    await manager.leave({ guildId: "g1" });
-
-    const player = createAudioPlayerMock.mock.results[0]?.value;
-    expect(connection.receiver.speaking.off).toHaveBeenCalledWith("start", expect.any(Function));
-    expect(connection.receiver.speaking.off).toHaveBeenCalledWith("end", expect.any(Function));
-    expect(connection.off).toHaveBeenCalledWith("disconnected", expect.any(Function));
-    expect(connection.off).toHaveBeenCalledWith("destroyed", expect.any(Function));
-    expect(player.off).toHaveBeenCalledWith("error", expect.any(Function));
-  });
-
-  it("passes DAVE options to joinVoiceChannel", async () => {
-    const manager = createManager({
-      voice: {
-        daveEncryption: false,
-        decryptionFailureTolerance: 8,
-      },
-    });
-
-    await manager.join({ guildId: "g1", channelId: "1001" });
-
-    expect(joinVoiceChannelMock).toHaveBeenCalledWith(
-      expect.objectContaining({
-        daveEncryption: false,
-        decryptionFailureTolerance: 8,
-      }),
-    );
-  });
-
-  it("uses the default timeout for initial voice connection readiness", async () => {
-    const connection = createConnectionMock();
-    joinVoiceChannelMock.mockReturnValueOnce(connection);
-    const manager = createManager();
-
-    await manager.join({ guildId: "g1", channelId: "1001" });
-
-    expect(entersStateMock).toHaveBeenCalledWith(connection, "ready", 30_000);
-  });
-
-  it("uses configured voice connection and reconnect timeouts", async () => {
-    const connection = createConnectionMock();
-    joinVoiceChannelMock.mockReturnValueOnce(connection);
-    const manager = createManager({
-      voice: {
-        connectTimeoutMs: 45_000,
-        reconnectGraceMs: 20_000,
-      },
-    });
-
-    await manager.join({ guildId: "g1", channelId: "1001" });
-
-    expect(entersStateMock).toHaveBeenCalledWith(connection, "ready", 45_000);
-
-    entersStateMock.mockClear();
-    entersStateMock.mockRejectedValueOnce(new Error("still disconnected"));
-    entersStateMock.mockRejectedValueOnce(new Error("still disconnected"));
-
-    const disconnected = connection.handlers.get("disconnected");
-    expect(disconnected).toBeTypeOf("function");
-    await disconnected?.();
-
-    expect(entersStateMock).toHaveBeenCalledWith(connection, "signalling", 20_000);
-    expect(entersStateMock).toHaveBeenCalledWith(connection, "connecting", 20_000);
-    expect(connection.destroy).toHaveBeenCalledTimes(1);
-    expect(manager.status()).toEqual([]);
-  });
-
-  it("uses the default reconnect grace before destroying disconnected sessions", async () => {
-    const connection = createConnectionMock();
-    joinVoiceChannelMock.mockReturnValueOnce(connection);
-    const manager = createManager();
-
-    await manager.join({ guildId: "g1", channelId: "1001" });
-
-    entersStateMock.mockClear();
-    entersStateMock.mockRejectedValueOnce(new Error("still disconnected"));
-    entersStateMock.mockRejectedValueOnce(new Error("still disconnected"));
-
-    const disconnected = connection.handlers.get("disconnected");
-    expect(disconnected).toBeTypeOf("function");
-    await disconnected?.();
-
-    expect(entersStateMock).toHaveBeenCalledWith(connection, "signalling", 15_000);
-    expect(entersStateMock).toHaveBeenCalledWith(connection, "connecting", 15_000);
-    expect(connection.destroy).toHaveBeenCalledTimes(1);
-    expect(manager.status()).toEqual([]);
-  });
-
-  it("stores guild metadata on joined voice sessions", async () => {
-    const manager = createManager();
-
-    await manager.join({ guildId: "g1", channelId: "1001" });
-
-    const entry = (manager as unknown as { sessions: Map<string, unknown> }).sessions.get("g1") as
-      | { guildName?: string }
-      | undefined;
-    expect(entry?.guildName).toBe("Guild One");
-  });
-
-  it("enables DAVE receive passthrough after join", async () => {
-    const connection = createConnectionMock();
-    joinVoiceChannelMock.mockReturnValueOnce(connection);
-    const manager = createManager();
-
-    await manager.join({ guildId: "g1", channelId: "1001" });
-
-    expect(connection.daveSetPassthroughMode).toHaveBeenCalledWith(true, 30);
-  });
-
-  it("re-arms passthrough but still rejoin-recovers after repeated decrypt failures", async () => {
-    const connection = createConnectionMock();
-    joinVoiceChannelMock
-      .mockReturnValueOnce(connection)
-      .mockReturnValueOnce(createConnectionMock());
-    const manager = createManager();
-
-    await manager.join({ guildId: "g1", channelId: "1001" });
-    connection.daveSetPassthroughMode.mockClear();
-
-    emitDecryptFailure(manager);
-    emitDecryptFailure(manager);
-    emitDecryptFailure(manager);
-    await new Promise((resolve) => setTimeout(resolve, 0));
-    await new Promise((resolve) => setTimeout(resolve, 0));
-
-    expect(connection.daveSetPassthroughMode).toHaveBeenCalledWith(true, 15);
-    expect(joinVoiceChannelMock).toHaveBeenCalledTimes(2);
-  });
-
-  it("allows the same speaker to restart after finalize fires", async () => {
-    vi.useFakeTimers();
-    try {
-      const connection = createConnectionMock();
-      joinVoiceChannelMock.mockReturnValueOnce(connection);
-      const manager = createManager();
-
-      await manager.join({ guildId: "g1", channelId: "1001" });
-
-      const entry = (manager as unknown as { sessions: Map<string, unknown> }).sessions.get(
-        "g1",
-      ) as
-        | {
-            guildId: string;
-            channelId: string;
-            capture: {
-              activeSpeakers: Set<string>;
-              activeCaptureStreams: Map<
-                string,
-                { generation: number; stream: { destroy: () => void } }
-              >;
-              captureFinalizeTimers: Map<string, unknown>;
-              captureGenerations: Map<string, number>;
-            };
-          }
-        | undefined;
-      expect(entry).toBeDefined();
-
-      const firstStream = { destroy: vi.fn() };
-      entry?.capture.activeSpeakers.add("u1");
-      entry?.capture.captureGenerations.set("u1", 1);
-      entry?.capture.activeCaptureStreams.set("u1", { generation: 1, stream: firstStream });
-
-      (
-        manager as unknown as {
-          scheduleCaptureFinalize: (entry: unknown, userId: string, reason: string) => void;
-        }
-      ).scheduleCaptureFinalize(entry, "u1", "test");
-
-      await vi.advanceTimersByTimeAsync(1_200);
-
-      expect(firstStream.destroy).toHaveBeenCalledTimes(1);
-      expect(entry?.capture.activeSpeakers.has("u1")).toBe(false);
-
-      const secondStream = {
-        on: vi.fn(),
-        destroy: vi.fn(),
-        async *[Symbol.asyncIterator]() {},
-      };
-      connection.receiver.subscribe.mockReturnValueOnce(secondStream);
-
-      await (
-        manager as unknown as {
-          handleSpeakingStart: (entry: unknown, userId: string) => Promise<void>;
-        }
-      ).handleSpeakingStart(entry, "u1");
-
-      expect(connection.receiver.subscribe).toHaveBeenCalledWith(
-        "u1",
-        expect.objectContaining({ end: { behavior: "Manual" } }),
-      );
-    } finally {
-      vi.useRealTimers();
-    }
-  });
-
-  it("passes senderIsOwner=true for allowlisted voice speakers", async () => {
-    const client = createClient();
-    client.fetchMember.mockResolvedValue({
-      nickname: "Owner Nick",
-      user: {
-        id: "u-owner",
-        username: "owner",
-        globalName: "Owner",
-        discriminator: "1234",
-      },
-    });
-    const manager = createManager({ groupPolicy: "open", allowFrom: ["discord:u-owner"] }, client);
-    await processVoiceSegment(manager, "u-owner");
-
-    const commandArgs = agentCommandMock.mock.calls.at(-1)?.[0] as
-      | { senderIsOwner?: boolean }
-      | undefined;
-    expect(commandArgs?.senderIsOwner).toBe(true);
-  });
-
-  it("passes senderIsOwner=false for non-owner voice speakers", async () => {
-    const client = createClient();
-    client.fetchMember.mockResolvedValue({
-      nickname: "Guest Nick",
-      user: {
-        id: "u-guest",
-        username: "guest",
-        globalName: "Guest",
-        discriminator: "4321",
-      },
-    });
-    const manager = createManager({ groupPolicy: "open", allowFrom: ["discord:u-owner"] }, client, {
-      commands: { useAccessGroups: false },
-    });
-    await processVoiceSegment(manager, "u-guest");
-
-    const commandArgs = agentCommandMock.mock.calls.at(-1)?.[0] as
-      | { senderIsOwner?: boolean }
-      | undefined;
-    expect(commandArgs?.senderIsOwner).toBe(false);
-  });
-
-  it("passes configured model override to agent command in voice flow", async () => {
-    const client = createClient();
-    client.fetchMember.mockResolvedValue({
-      nickname: "Guest Nick",
-      user: {
-        id: "u-guest",
-        username: "guest",
-        globalName: "Guest",
-        discriminator: "4321",
-      },
-    });
-    const manager = createManager(
-      {
-        groupPolicy: "open",
-        voice: {
-          model: "openai/gpt-5.4-mini",
-        },
-      },
-      client,
-      {
-        commands: { useAccessGroups: false },
-      },
-    );
-    await processVoiceSegment(manager, "u-guest");
-
-    const commandArgs = agentCommandMock.mock.calls.at(-1)?.[0] as
-      | { allowModelOverride?: boolean; model?: string }
-      | undefined;
-
-    expect(commandArgs?.allowModelOverride).toBe(true);
-    expect(commandArgs?.model).toBe("openai/gpt-5.4-mini");
-  });
-
-  it("runs voice replies under Discord voice output policy", async () => {
-    agentCommandMock.mockResolvedValueOnce({
-      payloads: [{ text: "hello back" }],
-    } as never);
-
-    const client = createClient();
-    client.fetchMember.mockResolvedValue({
-      nickname: "Guest Nick",
-      user: {
-        id: "u-guest",
-        username: "guest",
-        globalName: "Guest",
-        discriminator: "4321",
-      },
-    });
-    const manager = createManager({ groupPolicy: "open" }, client, {
-      commands: { useAccessGroups: false },
-    });
-    await processVoiceSegment(manager, "u-guest");
-
-    const commandArgs = agentCommandMock.mock.calls.at(-1)?.[0] as
-      | { message?: string; messageChannel?: string; messageProvider?: string }
-      | undefined;
-
-    expect(commandArgs?.messageChannel).toBe("discord");
-    expect(commandArgs?.messageProvider).toBe("discord-voice");
-    expect(commandArgs?.message).toContain("Do not call the tts tool");
-    expect(textToSpeechMock).toHaveBeenCalledWith(
-      expect.objectContaining({
-        channel: "discord",
-        text: "hello back",
-      }),
-    );
-  });
-
-  it("passes per-channel system prompt overrides to voice agent runs", async () => {
-    const client = createClient();
-    client.fetchMember.mockResolvedValue({
-      nickname: "Guest Nick",
-      user: {
-        id: "u-guest",
-        username: "guest",
-        globalName: "Guest",
-        discriminator: "4321",
-      },
-    });
-    const manager = createManager(
-      {
-        groupPolicy: "open",
-        guilds: {
-          g1: {
-            channels: {
-              "1001": {
-                systemPrompt: "  Use short voice replies.  ",
-              },
-            },
-          },
-        },
-      },
-      client,
-      {
-        commands: { useAccessGroups: false },
-      },
-    );
-    await processVoiceSegment(manager, "u-guest");
-
-    const commandArgs = agentCommandMock.mock.calls.at(-1)?.[0] as
-      | { extraSystemPrompt?: string }
-      | undefined;
-
-    expect(commandArgs?.extraSystemPrompt).toBe("Use short voice replies.");
-  });
-
-  it("reuses speaker context cache for repeated segments from the same speaker", async () => {
-    const client = createClient();
-    client.fetchMember.mockResolvedValue({
-      nickname: "Cached Speaker",
-      user: {
-        id: "u-cache",
-        username: "cache",
-        globalName: "Cache",
-        discriminator: "1111",
-      },
-    });
-    const manager = createManager({ allowFrom: ["discord:u-cache"] }, client);
-    const runSegment = async () => await processVoiceSegment(manager, "u-cache");
-
-    await runSegment();
-    await runSegment();
-
-    expect(client.fetchMember).toHaveBeenCalledTimes(3);
-  });
-
-  it("persists full speaker context in cache writes", async () => {
-    const client = createClient();
-    client.fetchMember.mockResolvedValue({
-      nickname: "Role Speaker",
-      roles: ["role-voice"],
-      user: {
-        id: "u-role",
-        username: "role",
-        globalName: "Role",
-        discriminator: "2222",
-      },
-    });
-    const manager = createManager(
-      {
-        groupPolicy: "allowlist",
-        guilds: {
-          g1: {
-            channels: {
-              "1001": {
-                roles: ["role:role-voice"],
-              },
-            },
-          },
-        },
-      },
-      client,
-    );
-
-    await processVoiceSegment(manager, "u-role");
-
-    const cache = (
-      manager as unknown as {
-        speakerContext: {
-          cache: Map<
-            string,
-            {
-              id?: string;
-              label: string;
-              name?: string;
-              tag?: string;
-              senderIsOwner: boolean;
-              expiresAt: number;
-            }
-          >;
-        };
-      }
-    ).speakerContext.cache;
-    const cached = cache.get("g1:u-role");
-
-    expect(cached).toEqual(
-      expect.objectContaining({
-        id: "u-role",
-        label: "Role Speaker",
-      }),
-    );
-  });
-
-  it("re-fetches member roles for repeated voice auth checks", async () => {
-    const client = createClient();
-    client.fetchMember
-      .mockResolvedValueOnce({
-        nickname: "Role Speaker",
-        roles: ["role-voice"],
-        user: {
-          id: "u-role",
-          username: "role",
-          globalName: "Role",
-          discriminator: "2222",
-        },
-      })
-      .mockResolvedValueOnce({
-        nickname: "Role Speaker",
-        roles: ["role-voice"],
-        user: {
-          id: "u-role",
-          username: "role",
-          globalName: "Role",
-          discriminator: "2222",
-        },
-      })
-      .mockResolvedValueOnce({
-        nickname: "Role Speaker",
-        roles: [],
-        user: {
-          id: "u-role",
-          username: "role",
-          globalName: "Role",
-          discriminator: "2222",
-        },
-      })
-      .mockResolvedValue({
-        nickname: "Role Speaker",
-        roles: [],
-        user: {
-          id: "u-role",
-          username: "role",
-          globalName: "Role",
-          discriminator: "2222",
-        },
-      });
-    const manager = createManager(
-      {
-        groupPolicy: "allowlist",
-        guilds: {
-          g1: {
-            channels: {
-              "1001": {
-                roles: ["role:role-voice"],
-              },
-            },
-          },
-        },
-      },
-      client,
-    );
-
-    await processVoiceSegment(manager, "u-role");
-    await processVoiceSegment(manager, "u-role");
-
-    expect(agentCommandMock).toHaveBeenCalledTimes(1);
-    expect(client.fetchMember).toHaveBeenCalledTimes(3);
-  });
-
-  it("fetches guild metadata before allowlist checks when the session lacks a guild name", async () => {
-    const client = createClient();
-    client.fetchGuild.mockResolvedValue({ id: "g1", name: "Guild One" });
-    client.fetchMember.mockResolvedValue({
-      nickname: "Owner Nick",
-      user: {
-        id: "u-owner",
-        username: "owner",
-        globalName: "Owner",
-        discriminator: "1234",
-      },
-    });
-    const manager = createManager(
-      {
-        groupPolicy: "allowlist",
-        guilds: {
-          "guild-one": {
-            channels: {
-              "*": {
-                users: ["discord:u-owner"],
-              },
-            },
-          },
-        },
-      },
-      client,
-    );
-
-    await processVoiceSegment(manager, "u-owner");
-
-    expect(client.fetchGuild).toHaveBeenCalledWith("g1");
-    expect(agentCommandMock).toHaveBeenCalledTimes(1);
-  });
-
-  it("DiscordVoiceReadyListener: propagates autoJoin errors fire-and-forget without throwing", async () => {
-    const manager = createManager();
-    const autoJoinSpy = vi
-      .spyOn(manager, "autoJoin")
-      .mockRejectedValue(new Error("autoJoin rejected"));
-
-    const { DiscordVoiceReadyListener } = managerModule;
-    const listener = new DiscordVoiceReadyListener(manager);
-
-    await expect(listener.handle(undefined, undefined as never)).resolves.not.toThrow();
-    expect(autoJoinSpy).toHaveBeenCalledTimes(1);
-  });
-
-  it("DiscordVoiceResumedListener: runs autoJoin on gateway resume", async () => {
-    const manager = createManager();
-    const autoJoinSpy = vi.spyOn(manager, "autoJoin").mockResolvedValue(undefined);
-
-    const { DiscordVoiceResumedListener } = managerModule;
-    const listener = new DiscordVoiceResumedListener(manager);
-
-    await expect(listener.handle(undefined, undefined as never)).resolves.not.toThrow();
-    expect(autoJoinSpy).toHaveBeenCalledTimes(1);
-  });
-});