@kodelyth/discord 2026.5.39 → 2026.5.42

package/src/monitor/native-command.plugin-dispatch.test.ts

@@ -0,0 +1,1212 @@
+import { ChannelType } from "discord-api-types/v10";
+import type { NativeCommandSpec } from "klaw/plugin-sdk/command-auth";
+import { resolveDirectStatusReplyForSession } from "klaw/plugin-sdk/command-status-runtime";
+import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
+import {
+  clearPluginCommands,
+  executePluginCommand,
+  matchPluginCommand,
+  registerPluginCommand,
+} from "klaw/plugin-sdk/plugin-runtime";
+import { createTestRegistry, setActivePluginRegistry } from "klaw/plugin-sdk/plugin-test-runtime";
+import { dispatchReplyWithDispatcher } from "klaw/plugin-sdk/reply-dispatch-runtime";
+import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { defineThrowingDiscordChannelGetter } from "../test-support/partial-channel.js";
+import { resolveDiscordNativeInteractionRouteState } from "./native-command-route.js";
+import {
+  createMockCommandInteraction as createInteraction,
+  type MockCommandInteraction,
+} from "./native-command.test-helpers.js";
+import { createNoopThreadBindingManager } from "./thread-bindings.manager.js";
+
+let createDiscordNativeCommand: typeof import("./native-command.js").createDiscordNativeCommand;
+let discordNativeCommandTesting: typeof import("./native-command.js").testing;
+const runtimeModuleMocks = vi.hoisted(() => ({
+  matchPluginCommand: vi.fn(),
+  executePluginCommand: vi.fn(),
+  dispatchReplyWithDispatcher: vi.fn(),
+  resolveDirectStatusReplyForSession: vi.fn(),
+}));
+
+function createConfig(): KlawConfig {
+  return {
+    channels: {
+      discord: {
+        dm: { enabled: true, policy: "open", allowFrom: ["*"] },
+      },
+    },
+  } as KlawConfig;
+}
+
+function createConfiguredAcpBinding(params: {
+  channelId: string;
+  peerKind: "channel" | "direct";
+  agentId?: string;
+}) {
+  return {
+    type: "acp",
+    agentId: params.agentId ?? "codex",
+    match: {
+      channel: "discord",
+      accountId: "default",
+      peer: { kind: params.peerKind, id: params.channelId },
+    },
+    acp: {
+      mode: "persistent",
+    },
+  } as const;
+}
+
+function createConfiguredAcpCase(params: {
+  channelType: ChannelType;
+  channelId: string;
+  peerKind: "channel" | "direct";
+  guildId?: string;
+  guildName?: string;
+  includeChannelAccess?: boolean;
+  agentId?: string;
+}) {
+  return {
+    cfg: {
+      commands: {
+        useAccessGroups: false,
+      },
+      ...(params.includeChannelAccess === false
+        ? {}
+        : params.channelType === ChannelType.DM
+          ? {
+              channels: {
+                discord: {
+                  dm: { enabled: true, policy: "open", allowFrom: ["*"] },
+                },
+              },
+            }
+          : {
+              channels: {
+                discord: {
+                  guilds: {
+                    [params.guildId!]: {
+                      channels: {
+                        [params.channelId]: { enabled: true, requireMention: false },
+                      },
+                    },
+                  },
+                },
+              },
+            }),
+      bindings: [
+        createConfiguredAcpBinding({
+          channelId: params.channelId,
+          peerKind: params.peerKind,
+          agentId: params.agentId,
+        }),
+      ],
+    } as KlawConfig,
+    interaction: createInteraction({
+      channelType: params.channelType,
+      channelId: params.channelId,
+      guildId: params.guildId,
+      guildName: params.guildName,
+    }),
+  };
+}
+
+async function createNativeCommand(cfg: KlawConfig, commandSpec: NativeCommandSpec) {
+  return createDiscordNativeCommand({
+    command: commandSpec,
+    cfg,
+    discordConfig: cfg.channels?.discord ?? {},
+    accountId: "default",
+    sessionPrefix: "discord:slash",
+    ephemeralDefault: true,
+    threadBindings: createNoopThreadBindingManager("default"),
+  });
+}
+
+function createConfiguredRouteState(params: {
+  sessionKey: string;
+  agentId?: string;
+  accountId?: string;
+}) {
+  return {
+    route: {
+      agentId: params.agentId ?? "main",
+      channel: "discord",
+      accountId: params.accountId ?? "default",
+      sessionKey: params.sessionKey,
+      mainSessionKey: `agent:${params.agentId ?? "main"}:main`,
+      lastRoutePolicy: "session",
+      matchedBy: "binding.channel",
+    },
+    effectiveRoute: {
+      agentId: params.agentId ?? "main",
+      channel: "discord",
+      accountId: params.accountId ?? "default",
+      sessionKey: params.sessionKey,
+      mainSessionKey: `agent:${params.agentId ?? "main"}:main`,
+      lastRoutePolicy: "session",
+      matchedBy: "binding.channel",
+    },
+    boundSessionKey: params.sessionKey,
+    configuredRoute: null,
+    configuredBinding: null,
+    bindingReadiness: { ok: true } as const,
+  } satisfies Awaited<
+    ReturnType<typeof import("./native-command-route.js").resolveDiscordNativeInteractionRouteState>
+  >;
+}
+
+function createUnboundRouteState(params: {
+  sessionKey: string;
+  agentId?: string;
+  accountId?: string;
+}) {
+  return {
+    route: {
+      agentId: params.agentId ?? "main",
+      channel: "discord",
+      accountId: params.accountId ?? "default",
+      sessionKey: params.sessionKey,
+      mainSessionKey: `agent:${params.agentId ?? "main"}:main`,
+      lastRoutePolicy: "session",
+      matchedBy: "default",
+    },
+    effectiveRoute: {
+      agentId: params.agentId ?? "main",
+      channel: "discord",
+      accountId: params.accountId ?? "default",
+      sessionKey: params.sessionKey,
+      mainSessionKey: `agent:${params.agentId ?? "main"}:main`,
+      lastRoutePolicy: "session",
+      matchedBy: "default",
+    },
+    boundSessionKey: undefined,
+    configuredRoute: null,
+    configuredBinding: null,
+    bindingReadiness: null,
+  } satisfies Awaited<
+    ReturnType<typeof import("./native-command-route.js").resolveDiscordNativeInteractionRouteState>
+  >;
+}
+
+type MockCalls = {
+  mock: { calls: unknown[][] };
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function requireRecord(value: unknown, label: string): Record<string, unknown> {
+  expect(isRecord(value), `${label} should be an object`).toBe(true);
+  if (!isRecord(value)) {
+    throw new Error(`${label} should be an object`);
+  }
+  return value;
+}
+
+function expectFields(record: Record<string, unknown>, expected: Record<string, unknown>) {
+  for (const [key, value] of Object.entries(expected)) {
+    expect(record[key], key).toEqual(value);
+  }
+}
+
+function firstMockCall(mock: MockCalls, label: string): unknown[] {
+  const call = mock.mock.calls.at(0);
+  if (!call) {
+    throw new Error(`expected ${label} call`);
+  }
+  return call;
+}
+
+function firstMockArg(mock: MockCalls, label: string) {
+  return firstMockCall(mock, label)[0];
+}
+
+function expectSingleCallFirstArg(
+  mock: MockCalls,
+  expected: Record<string, unknown>,
+  label = "mock first argument",
+): Record<string, unknown> {
+  expect(mock.mock.calls).toHaveLength(1);
+  const record = requireRecord(firstMockArg(mock, label), label);
+  expectFields(record, expected);
+  return record;
+}
+
+function expectPluginCommandExecution(params: {
+  mock: MockCalls;
+  commandName: string;
+  expected: Record<string, unknown>;
+}) {
+  const payload = expectSingleCallFirstArg(params.mock, params.expected, "plugin command payload");
+  expect(requireRecord(payload.command, "plugin command").name).toBe(params.commandName);
+  return payload;
+}
+
+function expectFollowUpFields(
+  interaction: MockCommandInteraction,
+  expected: Record<string, unknown>,
+) {
+  return expectSingleCallFirstArg(
+    interaction.followUp as unknown as MockCalls,
+    expected,
+    "followUp",
+  );
+}
+
+function expectNoFollowUpContent(interaction: MockCommandInteraction, content: string) {
+  const calls = (interaction.followUp as unknown as MockCalls).mock.calls;
+  const matched = calls.some(([payload]) => isRecord(payload) && payload.content === content);
+  expect(matched).toBe(false);
+}
+
+async function createPluginCommand(params: { cfg: KlawConfig; name: string }) {
+  return createDiscordNativeCommand({
+    command: {
+      name: params.name,
+      description: "Pair",
+      acceptsArgs: true,
+    } satisfies NativeCommandSpec,
+    cfg: params.cfg,
+    discordConfig: params.cfg.channels?.discord ?? {},
+    accountId: "default",
+    sessionPrefix: "discord:slash",
+    ephemeralDefault: true,
+    threadBindings: createNoopThreadBindingManager("default"),
+  });
+}
+
+function registerPairPlugin(params?: { discordNativeName?: string }) {
+  expect(
+    registerPluginCommand("demo-plugin", {
+      name: "pair",
+      ...(params?.discordNativeName
+        ? {
+            nativeNames: {
+              telegram: "pair_device",
+              discord: params.discordNativeName,
+            },
+          }
+        : {}),
+      description: "Pair device",
+      acceptsArgs: true,
+      requireAuth: false,
+      handler: async ({ args }) => ({ text: `paired:${args ?? ""}` }),
+    }),
+  ).toEqual({ ok: true });
+}
+
+function registerScopedPairPlugin(
+  handler = vi.fn(async ({ args }: { args?: string }) => ({ text: `paired:${args ?? ""}` })),
+) {
+  expect(
+    registerPluginCommand("demo-plugin", {
+      name: "pair",
+      description: "Pair device",
+      acceptsArgs: true,
+      requireAuth: false,
+      requiredScopes: ["operator.pairing"],
+      handler,
+    }),
+  ).toEqual({ ok: true });
+  return handler;
+}
+
+async function expectPairCommandReply(params: {
+  cfg: KlawConfig;
+  commandName: string;
+  interaction: MockCommandInteraction;
+  expectedRegisteredName?: string;
+}) {
+  const command = await createPluginCommand({
+    cfg: params.cfg,
+    name: params.commandName,
+  });
+  const dispatchSpy = runtimeModuleMocks.dispatchReplyWithDispatcher;
+  const executeSpy = runtimeModuleMocks.executePluginCommand.mockResolvedValue({
+    text: "paired:now",
+  });
+  await (command as { run: (interaction: unknown) => Promise<void> }).run(
+    Object.assign(params.interaction, {
+      options: {
+        getString: () => "now",
+        getBoolean: () => null,
+        getFocused: () => "",
+      },
+    }) as unknown,
+  );
+
+  expect(dispatchSpy).not.toHaveBeenCalled();
+  expectPluginCommandExecution({
+    mock: executeSpy,
+    commandName: params.expectedRegisteredName ?? "pair",
+    expected: { args: "now" },
+  });
+  expectFollowUpFields(params.interaction, { content: "paired:now" });
+  expect(params.interaction.reply).not.toHaveBeenCalled();
+}
+
+async function createStatusCommand(cfg: KlawConfig) {
+  return await createNativeCommand(cfg, {
+    name: "status",
+    description: "Status",
+    acceptsArgs: false,
+  });
+}
+
+function createDispatchSpy() {
+  return runtimeModuleMocks.dispatchReplyWithDispatcher.mockResolvedValue({
+    counts: {
+      final: 1,
+      block: 0,
+      tool: 0,
+    },
+  } as never);
+}
+
+async function expectBoundStatusCommandDirectReply(params: {
+  cfg: KlawConfig;
+  interaction: MockCommandInteraction;
+  expectedPattern: RegExp;
+}) {
+  runtimeModuleMocks.matchPluginCommand.mockReturnValue(null);
+  const dispatchSpy = runtimeModuleMocks.dispatchReplyWithDispatcher;
+  const statusSpy = runtimeModuleMocks.resolveDirectStatusReplyForSession;
+  const command = await createStatusCommand(params.cfg);
+
+  await (command as { run: (interaction: unknown) => Promise<void> }).run(
+    params.interaction as unknown,
+  );
+
+  expect(dispatchSpy).not.toHaveBeenCalled();
+  expect(statusSpy).toHaveBeenCalledTimes(1);
+  const statusCall = firstMockArg(statusSpy, "resolveDirectStatusReplyForSession") as {
+    sessionKey?: string;
+  };
+  expect(statusCall.sessionKey).toMatch(params.expectedPattern);
+}
+
+describe("Discord native plugin command dispatch", () => {
+  beforeAll(async () => {
+    ({ createDiscordNativeCommand, testing: discordNativeCommandTesting } =
+      await import("./native-command.js"));
+  });
+
+  afterAll(() => {
+    clearPluginCommands();
+    setActivePluginRegistry(createTestRegistry());
+    discordNativeCommandTesting.setMatchPluginCommand(matchPluginCommand);
+    discordNativeCommandTesting.setExecutePluginCommand(executePluginCommand);
+    discordNativeCommandTesting.setDispatchReplyWithDispatcher(dispatchReplyWithDispatcher);
+    discordNativeCommandTesting.setResolveDirectStatusReplyForSession(
+      resolveDirectStatusReplyForSession,
+    );
+    discordNativeCommandTesting.setResolveDiscordNativeInteractionRouteState(
+      resolveDiscordNativeInteractionRouteState,
+    );
+  });
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    clearPluginCommands();
+    setActivePluginRegistry(createTestRegistry());
+    runtimeModuleMocks.matchPluginCommand.mockReset();
+    runtimeModuleMocks.matchPluginCommand.mockImplementation(matchPluginCommand);
+    runtimeModuleMocks.executePluginCommand.mockReset();
+    runtimeModuleMocks.executePluginCommand.mockImplementation(executePluginCommand);
+    runtimeModuleMocks.dispatchReplyWithDispatcher.mockReset();
+    runtimeModuleMocks.dispatchReplyWithDispatcher.mockResolvedValue({
+      counts: {
+        final: 1,
+        block: 0,
+        tool: 0,
+      },
+    } as never);
+    runtimeModuleMocks.resolveDirectStatusReplyForSession.mockReset();
+    runtimeModuleMocks.resolveDirectStatusReplyForSession.mockResolvedValue({
+      text: "status reply",
+    });
+    discordNativeCommandTesting.setMatchPluginCommand(
+      runtimeModuleMocks.matchPluginCommand as typeof import("klaw/plugin-sdk/plugin-runtime").matchPluginCommand,
+    );
+    discordNativeCommandTesting.setExecutePluginCommand(
+      runtimeModuleMocks.executePluginCommand as typeof import("klaw/plugin-sdk/plugin-runtime").executePluginCommand,
+    );
+    discordNativeCommandTesting.setDispatchReplyWithDispatcher(
+      runtimeModuleMocks.dispatchReplyWithDispatcher as typeof dispatchReplyWithDispatcher,
+    );
+    discordNativeCommandTesting.setResolveDirectStatusReplyForSession(
+      runtimeModuleMocks.resolveDirectStatusReplyForSession as typeof resolveDirectStatusReplyForSession,
+    );
+    discordNativeCommandTesting.setResolveDiscordNativeInteractionRouteState(async (params) =>
+      createUnboundRouteState({
+        sessionKey: params.isDirectMessage
+          ? `agent:main:discord:dm:${params.directUserId ?? "owner"}`
+          : `agent:main:discord:channel:${params.conversationId}`,
+        accountId: params.accountId,
+      }),
+    );
+  });
+
+  it("executes plugin commands from the real registry through the native Discord command path", async () => {
+    const cfg = createConfig();
+    const interaction = createInteraction();
+
+    registerPairPlugin();
+    await expectPairCommandReply({
+      cfg,
+      commandName: "pair",
+      interaction,
+    });
+  });
+
+  it("round-trips Discord native aliases through the real plugin registry", async () => {
+    const cfg = createConfig();
+    const interaction = createInteraction();
+
+    registerPairPlugin({ discordNativeName: "pairdiscord" });
+    await expectPairCommandReply({
+      cfg,
+      commandName: "pairdiscord",
+      interaction,
+    });
+  });
+
+  it("does not treat Discord DM allowlist users as scoped plugin command owners", async () => {
+    const cfg = {
+      channels: {
+        discord: {
+          dm: { enabled: true, policy: "open", allowFrom: ["user:owner"] },
+        },
+      },
+    } as KlawConfig;
+    const interaction = createInteraction();
+    interaction.options.getString.mockReturnValue("now");
+    const handler = registerScopedPairPlugin();
+    const command = await createPluginCommand({ cfg, name: "pair" });
+
+    await (command as { run: (interaction: unknown) => Promise<void> }).run(interaction as unknown);
+
+    expect(handler).not.toHaveBeenCalled();
+    expectFollowUpFields(interaction, {
+      content: "⚠️ This command requires gateway scope: operator.pairing.",
+    });
+    expect(interaction.reply).not.toHaveBeenCalled();
+  });
+
+  it("allows generic command owners to run scoped Discord plugin commands without gateway scopes", async () => {
+    const cfg = {
+      commands: {
+        ownerAllowFrom: ["discord:123456789012345678"],
+      },
+      channels: {
+        discord: {
+          dm: { enabled: true, policy: "open", allowFrom: ["*"] },
+        },
+      },
+    } as KlawConfig;
+    const interaction = createInteraction({ userId: "123456789012345678" });
+    interaction.options.getString.mockReturnValue("now");
+    const handler = registerScopedPairPlugin();
+    const command = await createPluginCommand({ cfg, name: "pair" });
+
+    await (command as { run: (interaction: unknown) => Promise<void> }).run(interaction as unknown);
+
+    expect(handler).toHaveBeenCalledTimes(1);
+    expectFollowUpFields(interaction, { content: "paired:now" });
+    expect(interaction.reply).not.toHaveBeenCalled();
+  });
+
+  it("rejects authorized Discord non-owners for scoped plugin commands without gateway scopes", async () => {
+    const cfg = createConfig();
+    const interaction = createInteraction({ userId: "authorized-non-owner" });
+    interaction.options.getString.mockReturnValue("now");
+    const handler = registerScopedPairPlugin();
+    const command = await createPluginCommand({ cfg, name: "pair" });
+
+    await (command as { run: (interaction: unknown) => Promise<void> }).run(interaction as unknown);
+
+    expect(handler).not.toHaveBeenCalled();
+    expectFollowUpFields(interaction, {
+      content: "⚠️ This command requires gateway scope: operator.pairing.",
+    });
+    expect(interaction.reply).not.toHaveBeenCalled();
+  });
+
+  it("blocks unauthorized Discord senders before requireAuth:false plugin commands execute", async () => {
+    const cfg = {
+      commands: {
+        allowFrom: {
+          discord: ["user:123456789012345678"],
+        },
+      },
+      channels: {
+        discord: {
+          groupPolicy: "allowlist",
+          guilds: {
+            "345678901234567890": {
+              channels: {
+                "234567890123456789": {
+                  enabled: true,
+                  requireMention: false,
+                },
+              },
+            },
+          },
+        },
+      },
+    } as KlawConfig;
+    const commandSpec: NativeCommandSpec = {
+      name: "pair",
+      description: "Pair",
+      acceptsArgs: true,
+    };
+    const interaction = createInteraction({
+      channelType: ChannelType.GuildText,
+      channelId: "234567890123456789",
+      guildId: "345678901234567890",
+      guildName: "Test Guild",
+    });
+    interaction.user.id = "999999999999999999";
+    interaction.options.getString.mockReturnValue("now");
+
+    expect(
+      registerPluginCommand("demo-plugin", {
+        name: "pair",
+        description: "Pair device",
+        acceptsArgs: true,
+        requireAuth: false,
+        handler: async ({ args }) => ({ text: `open:${args ?? ""}` }),
+      }),
+    ).toEqual({ ok: true });
+    const command = await createNativeCommand(cfg, commandSpec);
+
+    const executeSpy = runtimeModuleMocks.executePluginCommand;
+    const dispatchSpy = runtimeModuleMocks.dispatchReplyWithDispatcher.mockResolvedValue(
+      {} as never,
+    );
+
+    await (command as { run: (interaction: unknown) => Promise<void> }).run(interaction as unknown);
+
+    expect(executeSpy).not.toHaveBeenCalled();
+    expect(dispatchSpy).not.toHaveBeenCalled();
+    expectFollowUpFields(interaction, {
+      content: "You are not authorized to use this command.",
+      ephemeral: true,
+    });
+    expect(interaction.reply).not.toHaveBeenCalled();
+  });
+
+  it("ignores non-Discord generic command owners when authorizing guild plugin commands", async () => {
+    const cfg = {
+      commands: {
+        ownerAllowFrom: ["telegram:123456789"],
+      },
+      channels: {
+        discord: {
+          groupPolicy: "allowlist",
+          guilds: {
+            "345678901234567890": {
+              channels: {
+                "234567890123456789": {
+                  enabled: true,
+                  requireMention: false,
+                },
+              },
+            },
+          },
+        },
+      },
+    } as KlawConfig;
+    const commandSpec: NativeCommandSpec = {
+      name: "pair",
+      description: "Pair",
+      acceptsArgs: true,
+    };
+    const interaction = createInteraction({
+      channelType: ChannelType.GuildText,
+      channelId: "234567890123456789",
+      guildId: "345678901234567890",
+      guildName: "Test Guild",
+    });
+    interaction.user.id = "999999999999999999";
+    interaction.options.getString.mockReturnValue("now");
+
+    expect(
+      registerPluginCommand("demo-plugin", {
+        name: "pair",
+        description: "Pair device",
+        acceptsArgs: true,
+        requireAuth: false,
+        handler: async ({ args }) => ({ text: `open:${args ?? ""}` }),
+      }),
+    ).toEqual({ ok: true });
+    const executeSpy = runtimeModuleMocks.executePluginCommand.mockResolvedValue({
+      text: "open:now",
+    });
+    const command = await createNativeCommand(cfg, commandSpec);
+
+    await (command as { run: (interaction: unknown) => Promise<void> }).run(interaction as unknown);
+
+    expectPluginCommandExecution({
+      mock: executeSpy,
+      commandName: "pair",
+      expected: { args: "now" },
+    });
+    expectFollowUpFields(interaction, { content: "open:now" });
+    expect(interaction.reply).not.toHaveBeenCalled();
+  });
+
+  it("keeps non-matching Discord command owners from restricting guild plugin commands", async () => {
+    const cfg = {
+      commands: {
+        ownerAllowFrom: ["discord:123456789012345678"],
+      },
+      channels: {
+        discord: {
+          groupPolicy: "allowlist",
+          guilds: {
+            "345678901234567890": {
+              channels: {
+                "234567890123456789": {
+                  enabled: true,
+                  requireMention: false,
+                },
+              },
+            },
+          },
+        },
+      },
+    } as KlawConfig;
+    const commandSpec: NativeCommandSpec = {
+      name: "pair",
+      description: "Pair",
+      acceptsArgs: true,
+    };
+    const interaction = createInteraction({
+      channelType: ChannelType.GuildText,
+      channelId: "234567890123456789",
+      guildId: "345678901234567890",
+      guildName: "Test Guild",
+    });
+    interaction.user.id = "999999999999999999";
+    interaction.options.getString.mockReturnValue("now");
+
+    expect(
+      registerPluginCommand("demo-plugin", {
+        name: "pair",
+        description: "Pair device",
+        acceptsArgs: true,
+        requireAuth: false,
+        handler: async ({ args }) => ({ text: `open:${args ?? ""}` }),
+      }),
+    ).toEqual({ ok: true });
+    const executeSpy = runtimeModuleMocks.executePluginCommand.mockResolvedValue({
+      text: "open:now",
+    });
+    const command = await createNativeCommand(cfg, commandSpec);
+
+    await (command as { run: (interaction: unknown) => Promise<void> }).run(interaction as unknown);
+
+    expectPluginCommandExecution({
+      mock: executeSpy,
+      commandName: "pair",
+      expected: { args: "now" },
+    });
+    expectFollowUpFields(interaction, { content: "open:now" });
+    expect(interaction.reply).not.toHaveBeenCalled();
+  });
+
+  it("rejects group DM slash commands outside dm.groupChannels before dispatch", async () => {
+    const cfg = {
+      commands: {
+        allowFrom: {
+          discord: ["user:owner"],
+        },
+      },
+      channels: {
+        discord: {
+          dm: {
+            enabled: true,
+            policy: "open",
+            groupEnabled: true,
+            groupChannels: ["allowed-group"],
+          },
+        },
+      },
+    } as KlawConfig;
+    const interaction = createInteraction({
+      channelType: ChannelType.GroupDM,
+      channelId: "blocked-group",
+    });
+    const dispatchSpy = createDispatchSpy();
+    const command = await createStatusCommand(cfg);
+
+    await (command as { run: (interaction: unknown) => Promise<void> }).run(interaction as unknown);
+
+    expect(dispatchSpy).not.toHaveBeenCalled();
+    expectFollowUpFields(interaction, {
+      content: "This group DM is not allowed.",
+    });
+    expect(interaction.reply).not.toHaveBeenCalled();
+  });
+
+  it("executes matched plugin commands directly without invoking the agent dispatcher", async () => {
+    const cfg = createConfig();
+    const commandSpec: NativeCommandSpec = {
+      name: "cron_jobs",
+      description: "List cron jobs",
+      acceptsArgs: false,
+    };
+    const interaction = createInteraction();
+    const pluginMatch = {
+      command: {
+        name: "cron_jobs",
+        description: "List cron jobs",
+        pluginId: "cron-jobs",
+        acceptsArgs: false,
+        handler: vi.fn().mockResolvedValue({ text: "jobs" }),
+      },
+      args: undefined,
+    };
+
+    runtimeModuleMocks.matchPluginCommand.mockReturnValue(pluginMatch as never);
+    const executeSpy = runtimeModuleMocks.executePluginCommand.mockResolvedValue({
+      text: "direct plugin output",
+    });
+    const dispatchSpy = runtimeModuleMocks.dispatchReplyWithDispatcher.mockResolvedValue(
+      {} as never,
+    );
+    const command = await createNativeCommand(cfg, commandSpec);
+
+    await (command as { run: (interaction: unknown) => Promise<void> }).run(interaction as unknown);
+
+    expect(executeSpy).toHaveBeenCalledTimes(1);
+    expect(dispatchSpy).not.toHaveBeenCalled();
+    expectFollowUpFields(interaction, { content: "direct plugin output" });
+    expect(interaction.reply).not.toHaveBeenCalled();
+  });
+
+  it("returns an explicit warning instead of success when dispatch produces zero visible replies", async () => {
+    const cfg = createConfig();
+    const interaction = createInteraction();
+    runtimeModuleMocks.matchPluginCommand.mockReturnValue(null);
+    runtimeModuleMocks.dispatchReplyWithDispatcher.mockResolvedValue({
+      counts: { final: 0, block: 0, tool: 0 },
+      queuedFinal: false,
+    } as never);
+    const command = await createNativeCommand(cfg, {
+      name: "new",
+      description: "Start a new session.",
+      acceptsArgs: true,
+    });
+
+    await (command as { run: (interaction: unknown) => Promise<void> }).run(interaction as unknown);
+
+    expectFollowUpFields(interaction, {
+      content: "⚠️ Command produced no visible reply.",
+      ephemeral: true,
+    });
+    expect(interaction.reply).not.toHaveBeenCalled();
+  });
+
+  it("does not warn when dispatch reports a queued final without visible counts", async () => {
+    const cfg = createConfig();
+    const interaction = createInteraction();
+    runtimeModuleMocks.matchPluginCommand.mockReturnValue(null);
+    runtimeModuleMocks.dispatchReplyWithDispatcher.mockResolvedValue({
+      counts: { final: 0, block: 0, tool: 0 },
+      queuedFinal: true,
+    } as never);
+    const command = await createNativeCommand(cfg, {
+      name: "new",
+      description: "Start a new session.",
+      acceptsArgs: true,
+    });
+
+    await (command as { run: (interaction: unknown) => Promise<void> }).run(interaction as unknown);
+
+    expectNoFollowUpContent(interaction, "⚠️ Command produced no visible reply.");
+    expect(interaction.reply).not.toHaveBeenCalled();
+  });
+
+  it("returns an explicit warning when a direct plugin command has no visible reply", async () => {
+    const cfg = createConfig();
+    const commandSpec: NativeCommandSpec = {
+      name: "cron_jobs",
+      description: "List cron jobs",
+      acceptsArgs: false,
+    };
+    const interaction = createInteraction();
+    const pluginMatch = {
+      command: {
+        name: "cron_jobs",
+        description: "List cron jobs",
+        pluginId: "cron-jobs",
+        acceptsArgs: false,
+        handler: vi.fn().mockResolvedValue({ text: "" }),
+      },
+      args: undefined,
+    };
+
+    runtimeModuleMocks.matchPluginCommand.mockReturnValue(pluginMatch as never);
+    runtimeModuleMocks.executePluginCommand.mockResolvedValue({});
+    const dispatchSpy = runtimeModuleMocks.dispatchReplyWithDispatcher.mockResolvedValue(
+      {} as never,
+    );
+    const command = await createNativeCommand(cfg, commandSpec);
+
+    await (command as { run: (interaction: unknown) => Promise<void> }).run(interaction as unknown);
+
+    expect(dispatchSpy).not.toHaveBeenCalled();
+    expectFollowUpFields(interaction, { content: "⚠️ Command produced no visible reply." });
+    expect(interaction.reply).not.toHaveBeenCalled();
+  });
+
+  it("forwards Discord thread metadata into direct plugin command execution", async () => {
+    const cfg = {
+      commands: {
+        useAccessGroups: false,
+      },
+      channels: {
+        discord: {
+          groupPolicy: "allowlist",
+          guilds: {
+            "345678901234567890": {
+              channels: {
+                "thread-123": {
+                  enabled: true,
+                  requireMention: false,
+                  users: ["user:owner"],
+                },
+                "parent-456": {
+                  enabled: true,
+                  requireMention: false,
+                  users: ["user:owner"],
+                },
+              },
+            },
+          },
+        },
+      },
+    } as KlawConfig;
+    const commandSpec: NativeCommandSpec = {
+      name: "cron_jobs",
+      description: "List cron jobs",
+      acceptsArgs: false,
+    };
+    const interaction = createInteraction({
+      channelType: ChannelType.PublicThread,
+      channelId: "thread-123",
+      threadParentId: "parent-456",
+      guildId: "345678901234567890",
+      guildName: "Test Guild",
+    });
+    const pluginMatch = {
+      command: {
+        name: "cron_jobs",
+        description: "List cron jobs",
+        pluginId: "cron-jobs",
+        acceptsArgs: false,
+        handler: vi.fn().mockResolvedValue({ text: "jobs" }),
+      },
+      args: undefined,
+    };
+
+    runtimeModuleMocks.matchPluginCommand.mockReturnValue(pluginMatch as never);
+    const executeSpy = runtimeModuleMocks.executePluginCommand.mockResolvedValue({
+      text: "direct plugin output",
+    });
+    const command = await createNativeCommand(cfg, commandSpec);
+
+    await (command as { run: (interaction: unknown) => Promise<void> }).run(interaction as unknown);
+
+    expectSingleCallFirstArg(executeSpy, {
+      channel: "discord",
+      from: "discord:channel:thread-123",
+      to: "slash:owner",
+      sessionKey: "agent:main:discord:channel:thread-123",
+      messageThreadId: "thread-123",
+      threadParentId: "parent-456",
+    });
+  });
+
+  it("preserves fetched thread parent metadata when interaction parentId getter throws", async () => {
+    const cfg = {
+      commands: {
+        useAccessGroups: false,
+      },
+      channels: {
+        discord: {
+          groupPolicy: "allowlist",
+          guilds: {
+            "345678901234567890": {
+              channels: {
+                "partial-thread-123": {
+                  enabled: true,
+                  requireMention: false,
+                  users: ["user:owner"],
+                },
+                "partial-parent-456": {
+                  enabled: true,
+                  requireMention: false,
+                  users: ["user:owner"],
+                },
+              },
+            },
+          },
+        },
+      },
+    } as KlawConfig;
+    const commandSpec: NativeCommandSpec = {
+      name: "cron_jobs",
+      description: "List cron jobs",
+      acceptsArgs: false,
+    };
+    const interaction = createInteraction({
+      channelType: ChannelType.PublicThread,
+      channelId: "partial-thread-123",
+      guildId: "345678901234567890",
+      guildName: "Test Guild",
+    });
+    defineThrowingDiscordChannelGetter(interaction.channel, "parentId");
+    (interaction.client as { fetchChannel: ReturnType<typeof vi.fn> }).fetchChannel = vi.fn(
+      async (channelId: string) => {
+        if (channelId === "partial-thread-123") {
+          return {
+            id: "partial-thread-123",
+            type: ChannelType.PublicThread,
+            parentId: "partial-parent-456",
+          };
+        }
+        if (channelId === "partial-parent-456") {
+          return { id: "partial-parent-456", type: ChannelType.GuildText, name: "Parent" };
+        }
+        return null;
+      },
+    );
+    const pluginMatch = {
+      command: {
+        name: "cron_jobs",
+        description: "List cron jobs",
+        pluginId: "cron-jobs",
+        acceptsArgs: false,
+        handler: vi.fn().mockResolvedValue({ text: "jobs" }),
+      },
+      args: undefined,
+    };
+
+    runtimeModuleMocks.matchPluginCommand.mockReturnValue(pluginMatch as never);
+    const executeSpy = runtimeModuleMocks.executePluginCommand.mockResolvedValue({
+      text: "direct plugin output",
+    });
+    const command = await createNativeCommand(cfg, commandSpec);
+
+    await (command as { run: (interaction: unknown) => Promise<void> }).run(interaction as unknown);
+
+    expectSingleCallFirstArg(executeSpy, {
+      channel: "discord",
+      from: "discord:channel:partial-thread-123",
+      messageThreadId: "partial-thread-123",
+      threadParentId: "partial-parent-456",
+    });
+  });
+
+  it("routes native slash commands through configured ACP Discord channel bindings", async () => {
+    const { cfg, interaction } = createConfiguredAcpCase({
+      channelType: ChannelType.GuildText,
+      channelId: "1478836151241412759",
+      peerKind: "channel",
+      guildId: "1459246755253325866",
+      guildName: "Ops",
+    });
+    discordNativeCommandTesting.setResolveDiscordNativeInteractionRouteState(async () =>
+      createConfiguredRouteState({
+        sessionKey: "agent:codex:acp:binding:discord:default:guild-channel",
+        agentId: "codex",
+      }),
+    );
+
+    await expectBoundStatusCommandDirectReply({
+      cfg,
+      interaction,
+      expectedPattern: /^agent:codex:acp:binding:discord:default:/,
+    });
+  });
+
+  it("falls back to the routed slash and channel session keys when no bound session exists", async () => {
+    const guildId = "1459246755253325866";
+    const channelId = "1478836151241412759";
+    const cfg = {
+      commands: {
+        useAccessGroups: false,
+      },
+      bindings: [
+        {
+          agentId: "qwen",
+          match: {
+            channel: "discord",
+            accountId: "default",
+            peer: { kind: "channel", id: channelId },
+            guildId,
+          },
+        },
+      ],
+      channels: {
+        discord: {
+          guilds: {
+            [guildId]: {
+              channels: {
+                [channelId]: { enabled: true, requireMention: false },
+              },
+            },
+          },
+        },
+      },
+    } as KlawConfig;
+    const interaction = createInteraction({
+      channelType: ChannelType.GuildText,
+      channelId,
+      guildId,
+      guildName: "Ops",
+    });
+
+    discordNativeCommandTesting.setResolveDiscordNativeInteractionRouteState(async () =>
+      createUnboundRouteState({
+        sessionKey: `agent:qwen:discord:channel:${channelId}`,
+        agentId: "qwen",
+      }),
+    );
+    runtimeModuleMocks.matchPluginCommand.mockReturnValue(null);
+    const dispatchSpy = runtimeModuleMocks.dispatchReplyWithDispatcher;
+    const statusSpy = runtimeModuleMocks.resolveDirectStatusReplyForSession;
+    const command = await createStatusCommand(cfg);
+    discordNativeCommandTesting.setResolveDiscordNativeInteractionRouteState(async () => ({
+      route: {
+        agentId: "qwen",
+        channel: "discord",
+        accountId: "default",
+        sessionKey: "agent:qwen:discord:channel:1478836151241412759",
+        mainSessionKey: "agent:qwen:main",
+        lastRoutePolicy: "session",
+        matchedBy: "binding.channel",
+      },
+      effectiveRoute: {
+        agentId: "qwen",
+        channel: "discord",
+        accountId: "default",
+        sessionKey: "agent:qwen:discord:channel:1478836151241412759",
+        mainSessionKey: "agent:qwen:main",
+        lastRoutePolicy: "session",
+        matchedBy: "binding.channel",
+      },
+      boundSessionKey: undefined,
+      configuredRoute: null,
+      configuredBinding: null,
+      bindingReadiness: null,
+    }));
+
+    await (command as { run: (interaction: unknown) => Promise<void> }).run(interaction as unknown);
+
+    expect(dispatchSpy).not.toHaveBeenCalled();
+    expect(statusSpy).toHaveBeenCalledTimes(1);
+    const statusCall = firstMockArg(statusSpy, "resolveDirectStatusReplyForSession") as {
+      sessionKey?: string;
+    };
+    expect(statusCall.sessionKey).toBe("agent:qwen:discord:channel:1478836151241412759");
+  });
+
+  it("routes Discord DM native slash commands through configured ACP bindings", async () => {
+    const { cfg, interaction } = createConfiguredAcpCase({
+      channelType: ChannelType.DM,
+      channelId: "dm-1",
+      peerKind: "direct",
+    });
+    discordNativeCommandTesting.setResolveDiscordNativeInteractionRouteState(async () =>
+      createConfiguredRouteState({
+        sessionKey: "agent:codex:acp:binding:discord:default:dm",
+        agentId: "codex",
+      }),
+    );
+
+    await expectBoundStatusCommandDirectReply({
+      cfg,
+      interaction,
+      expectedPattern: /^agent:codex:acp:binding:discord:default:/,
+    });
+  });
+
+  it("does not bypass configured ACP readiness for Discord /new", async () => {
+    const { cfg, interaction } = createConfiguredAcpCase({
+      channelType: ChannelType.GuildText,
+      channelId: "1478844424791396446",
+      peerKind: "channel",
+      guildId: "1459246755253325866",
+      guildName: "Ops",
+    });
+    const resolveRouteState = vi.fn(async () =>
+      createConfiguredRouteState({
+        sessionKey: "agent:claude:acp:binding:discord:default:9373ab192b2317f4",
+        agentId: "claude",
+      }),
+    );
+    discordNativeCommandTesting.setResolveDiscordNativeInteractionRouteState(resolveRouteState);
+    runtimeModuleMocks.matchPluginCommand.mockReturnValue(null);
+    const dispatchSpy = createDispatchSpy();
+    const command = await createNativeCommand(cfg, {
+      name: "new",
+      description: "Start a new session.",
+      acceptsArgs: true,
+    });
+
+    await (command as { run: (interaction: unknown) => Promise<void> }).run(interaction as unknown);
+
+    expectSingleCallFirstArg(resolveRouteState, {
+      enforceConfiguredBindingReadiness: true,
+    });
+    expect(dispatchSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("allows recovery commands through configured ACP bindings even when ensure fails", async () => {
+    const { cfg, interaction } = createConfiguredAcpCase({
+      channelType: ChannelType.GuildText,
+      channelId: "1479098716916023408",
+      peerKind: "channel",
+      guildId: "1459246755253325866",
+      guildName: "Ops",
+      includeChannelAccess: false,
+    });
+    discordNativeCommandTesting.setResolveDiscordNativeInteractionRouteState(async () =>
+      createConfiguredRouteState({
+        sessionKey: "agent:codex:acp:binding:discord:default:recovery",
+        agentId: "codex",
+      }),
+    );
+    runtimeModuleMocks.matchPluginCommand.mockReturnValue(null);
+    const dispatchSpy = createDispatchSpy();
+    const command = await createNativeCommand(cfg, {
+      name: "new",
+      description: "Start a new session.",
+      acceptsArgs: true,
+    });
+
+    await (command as { run: (interaction: unknown) => Promise<void> }).run(interaction as unknown);
+
+    expect(dispatchSpy).toHaveBeenCalledTimes(1);
+    const dispatchCall = firstMockArg(dispatchSpy, "dispatchReplyWithDispatcher") as {
+      ctx?: { SessionKey?: string; CommandTargetSessionKey?: string };
+    };
+    expect(dispatchCall.ctx?.SessionKey).toMatch(/^agent:codex:acp:binding:discord:default:/);
+    expect(dispatchCall.ctx?.CommandTargetSessionKey).toMatch(
+      /^agent:codex:acp:binding:discord:default:/,
+    );
+    const replyCalls = (interaction.reply as unknown as MockCalls).mock.calls;
+    const blockedReply = replyCalls.some(
+      ([payload]) =>
+        isRecord(payload) &&
+        payload.content === "Configured ACP binding is unavailable right now. Please try again.",
+    );
+    expect(blockedReply).toBe(false);
+  });
+});