@gakr-gakr/discord 0.1.0

package/src/monitor/native-command-agent-reply.ts

@@ -0,0 +1,125 @@
+import { resolveHumanDelayConfig } from "autobot/plugin-sdk/agent-runtime";
+import { createChannelMessageReplyPipeline } from "autobot/plugin-sdk/channel-message";
+import { resolveChannelStreamingBlockEnabled } from "autobot/plugin-sdk/channel-streaming";
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import { getAgentScopedMediaLocalRoots } from "autobot/plugin-sdk/media-runtime";
+import { resolveChunkMode, resolveTextChunkLimit } from "autobot/plugin-sdk/reply-chunking";
+import type { createSubsystemLogger } from "autobot/plugin-sdk/runtime-env";
+import { logVerbose } from "autobot/plugin-sdk/runtime-env";
+import { resolveDiscordMaxLinesPerMessage } from "../accounts.js";
+import type {
+  ButtonInteraction,
+  CommandInteraction,
+  StringSelectMenuInteraction,
+} from "../internal/discord.js";
+import type { DiscordChannelConfigResolved } from "./allow-list.js";
+import type { buildDiscordNativeCommandContext } from "./native-command-context.js";
+import {
+  DISCORD_EMPTY_VISIBLE_REPLY_WARNING,
+  deliverDiscordInteractionReply,
+  isDiscordUnknownInteraction,
+  safeDiscordInteractionCall,
+} from "./native-command-reply.js";
+import { nativeCommandRuntime } from "./native-command.runtime.js";
+import type { DiscordConfig } from "./native-command.types.js";
+
+type NativeCommandEffectiveRoute = {
+  accountId: string;
+  agentId: string;
+};
+
+export async function dispatchDiscordNativeAgentReply(params: {
+  cfg: AutoBotConfig;
+  discordConfig: DiscordConfig;
+  accountId: string;
+  interaction: CommandInteraction | ButtonInteraction | StringSelectMenuInteraction;
+  ctxPayload: ReturnType<typeof buildDiscordNativeCommandContext>;
+  effectiveRoute: NativeCommandEffectiveRoute;
+  channelConfig: DiscordChannelConfigResolved | null;
+  mediaLocalRoots: ReturnType<typeof getAgentScopedMediaLocalRoots>;
+  preferFollowUp: boolean;
+  responseEphemeral?: boolean;
+  suppressReplies?: boolean;
+  log: ReturnType<typeof createSubsystemLogger>;
+}): Promise<void> {
+  const { onModelSelected, ...replyPipeline } = createChannelMessageReplyPipeline({
+    cfg: params.cfg,
+    agentId: params.effectiveRoute.agentId,
+    channel: "discord",
+    accountId: params.effectiveRoute.accountId,
+  });
+  const blockStreamingEnabled = resolveChannelStreamingBlockEnabled(params.discordConfig);
+
+  let didReply = false;
+  const dispatchResult = await nativeCommandRuntime.dispatchReplyWithDispatcher({
+    ctx: params.ctxPayload,
+    cfg: params.cfg,
+    dispatcherOptions: {
+      ...replyPipeline,
+      humanDelay: resolveHumanDelayConfig(params.cfg, params.effectiveRoute.agentId),
+      deliver: async (payload) => {
+        if (params.suppressReplies) {
+          return;
+        }
+        try {
+          await deliverDiscordInteractionReply({
+            interaction: params.interaction,
+            payload,
+            mediaLocalRoots: params.mediaLocalRoots,
+            textLimit: resolveTextChunkLimit(params.cfg, "discord", params.accountId, {
+              fallbackLimit: 2000,
+            }),
+            maxLinesPerMessage: resolveDiscordMaxLinesPerMessage({
+              cfg: params.cfg,
+              discordConfig: params.discordConfig,
+              accountId: params.accountId,
+            }),
+            preferFollowUp: params.preferFollowUp || didReply,
+            responseEphemeral: params.responseEphemeral,
+            chunkMode: resolveChunkMode(params.cfg, "discord", params.accountId),
+          });
+        } catch (error) {
+          if (isDiscordUnknownInteraction(error)) {
+            logVerbose("discord: interaction reply skipped (interaction expired)");
+            return;
+          }
+          throw error;
+        }
+        didReply = true;
+      },
+      onError: (err, info) => {
+        const message = err instanceof Error ? (err.stack ?? err.message) : String(err);
+        params.log.error(`discord slash ${info.kind} reply failed: ${message}`);
+      },
+    },
+    replyOptions: {
+      skillFilter: params.channelConfig?.skills,
+      disableBlockStreaming:
+        typeof blockStreamingEnabled === "boolean" ? !blockStreamingEnabled : undefined,
+      onModelSelected,
+    },
+  });
+
+  if (
+    params.suppressReplies ||
+    didReply ||
+    dispatchResult.queuedFinal ||
+    dispatchResult.counts.final !== 0 ||
+    dispatchResult.counts.block !== 0 ||
+    dispatchResult.counts.tool !== 0
+  ) {
+    return;
+  }
+
+  await safeDiscordInteractionCall("interaction empty fallback", async () => {
+    const payload = {
+      content: DISCORD_EMPTY_VISIBLE_REPLY_WARNING,
+      ephemeral: true,
+    };
+    if (params.preferFollowUp) {
+      await params.interaction.followUp(payload);
+      return;
+    }
+    await params.interaction.reply(payload);
+  });
+}

package/src/monitor/native-command-arg-ui.ts

@@ -0,0 +1,233 @@
+import { ButtonStyle } from "discord-api-types/v10";
+import {
+  buildCommandTextFromArgs,
+  findCommandByNativeName,
+  formatCommandArgMenuTitle,
+  listChatCommands,
+  serializeCommandArgs,
+  type ChatCommandDefinition,
+  type CommandArgDefinition,
+  type CommandArgValues,
+  type CommandArgs,
+} from "autobot/plugin-sdk/command-auth-native";
+import { chunkItems } from "autobot/plugin-sdk/text-chunking";
+import {
+  Button,
+  Row,
+  type ButtonInteraction,
+  type CommandInteraction,
+  type ComponentData,
+} from "../internal/discord.js";
+import { resolveDiscordSlashCommandConfig } from "./commands.js";
+import type { DispatchDiscordCommandInteraction } from "./native-command-dispatch.js";
+import type {
+  DiscordCommandArgContext,
+  SafeDiscordInteractionCall,
+} from "./native-command-ui.types.js";
+
+const DISCORD_COMMAND_ARG_CUSTOM_ID_KEY = "cmdarg";
+
+function createCommandArgsWithValue(params: { argName: string; value: string }): CommandArgs {
+  const values: CommandArgValues = { [params.argName]: params.value };
+  return { values };
+}
+
+function encodeDiscordCommandArgValue(value: string): string {
+  return encodeURIComponent(value);
+}
+
+function decodeDiscordCommandArgValue(value: string): string {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+
+export function buildDiscordCommandArgCustomId(params: {
+  command: string;
+  arg: string;
+  value: string;
+  userId: string;
+}): string {
+  return [
+    `${DISCORD_COMMAND_ARG_CUSTOM_ID_KEY}:command=${encodeDiscordCommandArgValue(params.command)}`,
+    `arg=${encodeDiscordCommandArgValue(params.arg)}`,
+    `value=${encodeDiscordCommandArgValue(params.value)}`,
+    `user=${encodeDiscordCommandArgValue(params.userId)}`,
+  ].join(";");
+}
+
+function parseDiscordCommandArgData(
+  data: ComponentData,
+): { command: string; arg: string; value: string; userId: string } | null {
+  if (!data || typeof data !== "object") {
+    return null;
+  }
+  const coerce = (value: unknown) =>
+    typeof value === "string" || typeof value === "number" ? String(value) : "";
+  const rawCommand = coerce(data.command);
+  const rawArg = coerce(data.arg);
+  const rawValue = coerce(data.value);
+  const rawUser = coerce(data.user);
+  if (!rawCommand || !rawArg || !rawValue || !rawUser) {
+    return null;
+  }
+  return {
+    command: decodeDiscordCommandArgValue(rawCommand),
+    arg: decodeDiscordCommandArgValue(rawArg),
+    value: decodeDiscordCommandArgValue(rawValue),
+    userId: decodeDiscordCommandArgValue(rawUser),
+  };
+}
+
+export async function handleDiscordCommandArgInteraction(params: {
+  interaction: ButtonInteraction;
+  data: ComponentData;
+  ctx: DiscordCommandArgContext;
+  safeInteractionCall: SafeDiscordInteractionCall;
+  dispatchCommandInteraction: DispatchDiscordCommandInteraction;
+}) {
+  const { interaction, data, ctx } = params;
+  const clearWithMessage = async (content: string) =>
+    await params.safeInteractionCall("command arg update", () =>
+      interaction.update({ content, components: [] }),
+    );
+  const parsed = parseDiscordCommandArgData(data);
+  if (!parsed) {
+    await clearWithMessage("Sorry, that selection is no longer available.");
+    return;
+  }
+  if (interaction.user?.id && interaction.user.id !== parsed.userId) {
+    await params.safeInteractionCall("command arg ack", () => interaction.acknowledge());
+    return;
+  }
+  const commandDefinition =
+    findCommandByNativeName(parsed.command, "discord") ??
+    listChatCommands().find((entry) => entry.key === parsed.command);
+  if (!commandDefinition) {
+    await clearWithMessage("Sorry, that command is no longer available.");
+    return;
+  }
+  const argUpdateResult = await clearWithMessage(`✅ Selected ${parsed.value}.`);
+  if (argUpdateResult === null) {
+    return;
+  }
+  const commandArgs = createCommandArgsWithValue({
+    argName: parsed.arg,
+    value: parsed.value,
+  });
+  const commandArgsWithRaw: CommandArgs = {
+    ...commandArgs,
+    raw: serializeCommandArgs(commandDefinition, commandArgs),
+  };
+  const prompt = buildCommandTextFromArgs(commandDefinition, commandArgsWithRaw);
+  await params.dispatchCommandInteraction({
+    interaction,
+    prompt,
+    command: commandDefinition,
+    commandArgs: commandArgsWithRaw,
+    cfg: ctx.cfg,
+    discordConfig: ctx.discordConfig,
+    accountId: ctx.accountId,
+    sessionPrefix: ctx.sessionPrefix,
+    preferFollowUp: true,
+    threadBindings: ctx.threadBindings,
+    responseEphemeral: resolveDiscordSlashCommandConfig(ctx.discordConfig?.slashCommand).ephemeral,
+  });
+}
+
+type DiscordCommandArgButtonParams = {
+  ctx: DiscordCommandArgContext;
+  safeInteractionCall: SafeDiscordInteractionCall;
+  dispatchCommandInteraction: DispatchDiscordCommandInteraction;
+};
+
+async function runDiscordCommandArgButton(
+  params: DiscordCommandArgButtonParams & {
+    interaction: ButtonInteraction;
+    data: ComponentData;
+  },
+) {
+  await handleDiscordCommandArgInteraction(params);
+}
+
+class DiscordCommandArgButton extends Button {
+  label: string;
+  customId: string;
+  override style = ButtonStyle.Secondary;
+
+  constructor(
+    params: {
+      label: string;
+      customId: string;
+    } & DiscordCommandArgButtonParams,
+  ) {
+    super();
+    this.label = params.label;
+    this.customId = params.customId;
+    this.params = params;
+  }
+
+  private params: DiscordCommandArgButtonParams;
+
+  override async run(interaction: ButtonInteraction, data: ComponentData) {
+    await runDiscordCommandArgButton({ ...this.params, interaction, data });
+  }
+}
+
+export function buildDiscordCommandArgMenu(params: {
+  command: ChatCommandDefinition;
+  menu: {
+    arg: CommandArgDefinition;
+    choices: Array<{ value: string; label: string }>;
+    title?: string;
+  };
+  interaction: CommandInteraction;
+  ctx: DiscordCommandArgContext;
+  safeInteractionCall: SafeDiscordInteractionCall;
+  dispatchCommandInteraction: DispatchDiscordCommandInteraction;
+}): { content: string; components: Row<Button>[] } {
+  const { command, menu, interaction } = params;
+  const commandLabel = command.nativeName ?? command.key;
+  const userId = interaction.user?.id ?? "";
+  const rows = chunkItems(menu.choices, 4).map((choices) => {
+    const buttons = choices.map(
+      (choice) =>
+        new DiscordCommandArgButton({
+          label: choice.label,
+          customId: buildDiscordCommandArgCustomId({
+            command: commandLabel,
+            arg: menu.arg.name,
+            value: choice.value,
+            userId,
+          }),
+          ctx: params.ctx,
+          safeInteractionCall: params.safeInteractionCall,
+          dispatchCommandInteraction: params.dispatchCommandInteraction,
+        }),
+    );
+    return new Row(buttons);
+  });
+  const content = formatCommandArgMenuTitle({ command, menu });
+  return { content, components: rows };
+}
+
+class DiscordCommandArgFallbackButton extends Button {
+  label = "cmdarg";
+  customId = "cmdarg:seed=1";
+
+  constructor(private readonly params: DiscordCommandArgButtonParams) {
+    super();
+  }
+
+  override async run(interaction: ButtonInteraction, data: ComponentData) {
+    await runDiscordCommandArgButton({ ...this.params, interaction, data });
+  }
+}
+
+export function createDiscordCommandArgFallbackButton(
+  params: DiscordCommandArgButtonParams,
+): Button {
+  return new DiscordCommandArgFallbackButton(params);
+}

package/src/monitor/native-command-auth.ts

@@ -0,0 +1,309 @@
+import { resolveCommandAuthorizedFromAuthorizers } from "autobot/plugin-sdk/command-auth-native";
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import { isDangerousNameMatchingEnabled } from "autobot/plugin-sdk/dangerous-name-runtime";
+import { resolveOpenProviderRuntimeGroupPolicy } from "autobot/plugin-sdk/runtime-group-policy";
+import { normalizeOptionalString } from "autobot/plugin-sdk/string-coerce-runtime";
+import { resolveDiscordAccountAllowFrom, resolveDiscordAccountDmPolicy } from "../accounts.js";
+import type { AutocompleteInteraction } from "../internal/discord.js";
+import {
+  normalizeDiscordAllowList,
+  resolveDiscordAllowListMatch,
+  resolveDiscordChannelConfigWithFallback,
+  resolveDiscordChannelPolicyCommandAuthorizer,
+  resolveDiscordGuildEntry,
+  resolveDiscordMemberAccessState,
+  resolveDiscordOwnerAccess,
+  resolveGroupDmAllow,
+} from "./allow-list.js";
+import { resolveDiscordDmCommandAccess } from "./dm-command-auth.js";
+import type { DiscordConfig } from "./native-command.types.js";
+import { resolveDiscordNativeInteractionChannelContext } from "./native-interaction-channel-context.js";
+import { resolveDiscordSenderIdentity } from "./sender-identity.js";
+
+export function resolveDiscordNativeCommandAllowlistAccess(params: {
+  cfg: AutoBotConfig;
+  accountId?: string | null;
+  sender: { id: string; name?: string; tag?: string };
+  chatType: "direct" | "group" | "thread" | "channel";
+  conversationId?: string;
+  guildId?: string | null;
+}) {
+  const commandsAllowFrom = params.cfg.commands?.allowFrom;
+  if (!commandsAllowFrom || typeof commandsAllowFrom !== "object") {
+    return { configured: false, allowed: false } as const;
+  }
+  const rawAllowList = Array.isArray(commandsAllowFrom.discord)
+    ? commandsAllowFrom.discord
+    : commandsAllowFrom["*"];
+  if (!Array.isArray(rawAllowList)) {
+    return { configured: false, allowed: false } as const;
+  }
+  const guildId = normalizeOptionalString(params.guildId);
+  if (guildId) {
+    for (const entry of rawAllowList) {
+      const text = normalizeOptionalString(String(entry)) ?? "";
+      if (text.startsWith("guild:") && text.slice("guild:".length) === guildId) {
+        return { configured: true, allowed: true } as const;
+      }
+    }
+  }
+  const allowList = normalizeDiscordAllowList(rawAllowList.map(String), [
+    "discord:",
+    "user:",
+    "pk:",
+  ]);
+  if (!allowList) {
+    return { configured: true, allowed: false } as const;
+  }
+  const match = resolveDiscordAllowListMatch({
+    allowList,
+    candidate: params.sender,
+    allowNameMatching: false,
+  });
+  return { configured: true, allowed: match.allowed } as const;
+}
+
+export async function resolveDiscordGuildNativeCommandAuthorized(params: {
+  cfg: AutoBotConfig;
+  accountId: string;
+  discordConfig: DiscordConfig;
+  useAccessGroups: boolean;
+  commandsAllowFromAccess: ReturnType<typeof resolveDiscordNativeCommandAllowlistAccess>;
+  guildInfo?: ReturnType<typeof resolveDiscordGuildEntry> | null;
+  channelConfig?: ReturnType<typeof resolveDiscordChannelConfigWithFallback> | null;
+  memberRoleIds: string[];
+  sender: { id: string; name?: string; tag?: string };
+  allowNameMatching: boolean;
+  ownerAllowListConfigured: boolean;
+  ownerAllowed: boolean;
+}) {
+  const { groupPolicy } = resolveOpenProviderRuntimeGroupPolicy({
+    providerConfigPresent: params.cfg.channels?.discord !== undefined,
+    groupPolicy: params.discordConfig?.groupPolicy,
+    defaultGroupPolicy: params.cfg.channels?.defaults?.groupPolicy,
+  });
+  const policyAuthorizer = resolveDiscordChannelPolicyCommandAuthorizer({
+    groupPolicy,
+    guildInfo: params.guildInfo,
+    channelConfig: params.channelConfig,
+  });
+  if (!policyAuthorizer.allowed) {
+    return false;
+  }
+  const { hasAccessRestrictions, memberAllowed } = resolveDiscordMemberAccessState({
+    channelConfig: params.channelConfig,
+    guildInfo: params.guildInfo,
+    memberRoleIds: params.memberRoleIds,
+    sender: params.sender,
+    allowNameMatching: params.allowNameMatching,
+  });
+  const commandAllowlistAuthorizer = {
+    configured: params.commandsAllowFromAccess.configured,
+    allowed: params.commandsAllowFromAccess.allowed,
+  };
+  const ownerAuthorizer = {
+    configured: params.ownerAllowListConfigured,
+    allowed: params.ownerAllowed,
+  };
+  const memberAuthorizer = {
+    configured: hasAccessRestrictions,
+    allowed: memberAllowed,
+  };
+  const hasStricterAccessRestrictions = ownerAuthorizer.configured || memberAuthorizer.configured;
+  const policyFallbackAuthorizer = {
+    configured: policyAuthorizer.configured && !hasStricterAccessRestrictions,
+    allowed: policyAuthorizer.allowed,
+  };
+  const fallbackAuthorizers = [policyFallbackAuthorizer, ownerAuthorizer, memberAuthorizer];
+  const authorizers = params.commandsAllowFromAccess.configured
+    ? [commandAllowlistAuthorizer]
+    : fallbackAuthorizers;
+  return resolveCommandAuthorizedFromAuthorizers({
+    useAccessGroups: params.useAccessGroups,
+    authorizers,
+    modeWhenAccessGroupsOff: "configured",
+  });
+}
+
+export function resolveDiscordNativeGroupDmAccess(params: {
+  isGroupDm: boolean;
+  groupEnabled?: boolean;
+  groupChannels?: string[];
+  channelId: string;
+  channelName?: string;
+  channelSlug: string;
+}): { allowed: true } | { allowed: false; reason: "disabled" | "not-allowlisted" } {
+  if (!params.isGroupDm) {
+    return { allowed: true };
+  }
+  if (params.groupEnabled === false) {
+    return { allowed: false, reason: "disabled" };
+  }
+  if (
+    !resolveGroupDmAllow({
+      channels: params.groupChannels,
+      channelId: params.channelId,
+      channelName: params.channelName,
+      channelSlug: params.channelSlug,
+    })
+  ) {
+    return { allowed: false, reason: "not-allowlisted" };
+  }
+  return { allowed: true };
+}
+
+export async function resolveDiscordNativeAutocompleteAuthorized(params: {
+  interaction: AutocompleteInteraction;
+  cfg: AutoBotConfig;
+  discordConfig: DiscordConfig;
+  accountId: string;
+}): Promise<boolean> {
+  const { interaction, cfg, discordConfig, accountId } = params;
+  const user = interaction.user;
+  if (!user) {
+    return false;
+  }
+  const sender = resolveDiscordSenderIdentity({ author: user, pluralkitInfo: null });
+  const {
+    isDirectMessage,
+    isGroupDm,
+    isThreadChannel,
+    channelName,
+    channelSlug,
+    rawChannelId,
+    threadParentId,
+    threadParentName,
+    threadParentSlug,
+  } = await resolveDiscordNativeInteractionChannelContext({
+    channel: interaction.channel,
+    client: interaction.client,
+    hasGuild: Boolean(interaction.guild),
+    channelIdFallback: "",
+  });
+  const memberRoleIds = Array.isArray(interaction.rawData.member?.roles)
+    ? interaction.rawData.member.roles.map((roleId: string) => roleId)
+    : [];
+  const allowNameMatching = isDangerousNameMatchingEnabled(discordConfig);
+  const useAccessGroups = cfg.commands?.useAccessGroups !== false;
+  const configuredDmAllowFrom =
+    resolveDiscordAccountAllowFrom({
+      cfg,
+      accountId,
+    }) ?? [];
+  const { ownerAllowList, ownerAllowed: ownerOk } = resolveDiscordOwnerAccess({
+    allowFrom: configuredDmAllowFrom,
+    sender: {
+      id: sender.id,
+      name: sender.name,
+      tag: sender.tag,
+    },
+    allowNameMatching,
+  });
+  const commandsAllowFromAccess = resolveDiscordNativeCommandAllowlistAccess({
+    cfg,
+    accountId,
+    sender: {
+      id: sender.id,
+      name: sender.name,
+      tag: sender.tag,
+    },
+    chatType: isDirectMessage
+      ? "direct"
+      : isThreadChannel
+        ? "thread"
+        : interaction.guild
+          ? "channel"
+          : "group",
+    conversationId: rawChannelId || undefined,
+    guildId: interaction.guild?.id,
+  });
+  const guildInfo = resolveDiscordGuildEntry({
+    guild: interaction.guild ?? undefined,
+    guildId: interaction.guild?.id ?? undefined,
+    guildEntries: discordConfig?.guilds,
+  });
+  const channelConfig = interaction.guild
+    ? resolveDiscordChannelConfigWithFallback({
+        guildInfo,
+        channelId: rawChannelId,
+        channelName,
+        channelSlug,
+        parentId: threadParentId,
+        parentName: threadParentName,
+        parentSlug: threadParentSlug,
+        scope: isThreadChannel ? "thread" : "channel",
+      })
+    : null;
+  if (channelConfig?.enabled === false) {
+    return false;
+  }
+  if (interaction.guild && channelConfig?.allowed === false) {
+    return false;
+  }
+  if (useAccessGroups && interaction.guild) {
+    const { groupPolicy } = resolveOpenProviderRuntimeGroupPolicy({
+      providerConfigPresent: cfg.channels?.discord !== undefined,
+      groupPolicy: discordConfig?.groupPolicy,
+      defaultGroupPolicy: cfg.channels?.defaults?.groupPolicy,
+    });
+    const policyAuthorizer = resolveDiscordChannelPolicyCommandAuthorizer({
+      groupPolicy,
+      guildInfo,
+      channelConfig,
+    });
+    if (!policyAuthorizer.allowed) {
+      return false;
+    }
+  }
+  const dmEnabled = discordConfig?.dm?.enabled ?? true;
+  const dmPolicy = resolveDiscordAccountDmPolicy({ cfg, accountId }) ?? "pairing";
+  if (isDirectMessage) {
+    if (!dmEnabled || dmPolicy === "disabled") {
+      return false;
+    }
+    const dmAccess = await resolveDiscordDmCommandAccess({
+      accountId,
+      dmPolicy,
+      configuredAllowFrom: configuredDmAllowFrom,
+      sender: {
+        id: sender.id,
+        name: sender.name,
+        tag: sender.tag,
+      },
+      allowNameMatching,
+      cfg,
+      rest: interaction.client.rest,
+    });
+    if (dmAccess.senderAccess.decision !== "allow") {
+      return false;
+    }
+  }
+  const groupDmAccess = resolveDiscordNativeGroupDmAccess({
+    isGroupDm,
+    groupEnabled: discordConfig?.dm?.groupEnabled,
+    groupChannels: discordConfig?.dm?.groupChannels,
+    channelId: rawChannelId,
+    channelName,
+    channelSlug,
+  });
+  if (!groupDmAccess.allowed) {
+    return false;
+  }
+  if (!isDirectMessage) {
+    return resolveDiscordGuildNativeCommandAuthorized({
+      cfg,
+      accountId,
+      discordConfig,
+      useAccessGroups,
+      commandsAllowFromAccess,
+      guildInfo,
+      channelConfig,
+      memberRoleIds,
+      sender,
+      allowNameMatching,
+      ownerAllowListConfigured: ownerAllowList != null,
+      ownerAllowed: ownerOk,
+    });
+  }
+  return true;
+}

package/src/monitor/native-command-bypass.ts

@@ -0,0 +1,13 @@
+import { normalizeLowercaseStringOrEmpty } from "autobot/plugin-sdk/string-coerce-runtime";
+
+export function shouldBypassConfiguredAcpEnsure(commandName: string): boolean {
+  const normalized = normalizeLowercaseStringOrEmpty(commandName);
+  // Recovery slash commands still need configured ACP readiness so stale dead
+  // bindings are recreated before /new or /reset dispatches through them.
+  return normalized === "acp";
+}
+
+export function shouldBypassConfiguredAcpGuildGuards(commandName: string): boolean {
+  const normalized = normalizeLowercaseStringOrEmpty(commandName);
+  return normalized === "new" || normalized === "reset";
+}