diff --git a/apps/bot/src/features/automation/system/eventBridge.ts b/apps/bot/src/features/automation/system/eventBridge.ts
index b05cf647..af33491e 100644
--- a/apps/bot/src/features/automation/system/eventBridge.ts
+++ b/apps/bot/src/features/automation/system/eventBridge.ts
@@ -211,7 +211,7 @@ export function registerActionEventListeners(client: Client): void {
 
   // Message created
   client.on("messageCreate", (message) => {
-    if (!message.guildId || message.author.bot) return;
+    if (!message.guildId || message.author?.bot) return;
     if (getRulesForEvent(message.guildId, "messageCreated").length === 0) return;
     const ctx = buildMessageContext("messageCreated", message);
     processEvent(client, ctx).catch((e) =>
@@ -229,24 +229,35 @@ export function registerActionEventListeners(client: Client): void {
     );
   });
 
-  // Reaction added/removed
-  client.on("messageReactionAdd", (reaction, user) => {
-    if (!reaction.message.guildId || user.bot) return;
-    if (getRulesForEvent(reaction.message.guildId, "reactionAdded").length === 0) return;
-    const ctx = buildReactionContext("reactionAdded", reaction, user);
-    processEvent(client, ctx).catch((e) =>
-      handleError("reactionAdded", e),
-    );
-  });
+  // Reaction added/removed.
+  //
+  // Partials are enabled on the client, so these fire for messages the bot has
+  // never cached — which is the normal case for a pinned rules message. Both
+  // the reaction and the user must be resolved before the context is built, or
+  // every reaction automation on an older message stays silently broken.
+  const onReaction = (
+    eventType: "reactionAdded" | "reactionRemoved",
+  ) => async (
+    reaction: MessageReaction | PartialMessageReaction,
+    user: User | PartialUser,
+  ) => {
+    try {
+      if (user.bot) return;
+      if (reaction.partial) await reaction.fetch();
+      if (user.partial) user = await user.fetch();
+      const guildId = reaction.message.guildId;
+      if (!guildId) return;
+      if (getRulesForEvent(guildId, eventType).length === 0) return;
+      await processEvent(client, buildReactionContext(eventType, reaction, user));
+    } catch (e) {
+      // A deleted message cannot be fetched back; that is not an error worth
+      // surfacing, but anything else is.
+      handleError(eventType, e);
+    }
+  };
 
-  client.on("messageReactionRemove", (reaction, user) => {
-    if (!reaction.message.guildId || user.bot) return;
-    if (getRulesForEvent(reaction.message.guildId, "reactionRemoved").length === 0) return;
-    const ctx = buildReactionContext("reactionRemoved", reaction, user);
-    processEvent(client, ctx).catch((e) =>
-      handleError("reactionRemoved", e),
-    );
-  });
+  client.on("messageReactionAdd", onReaction("reactionAdded"));
+  client.on("messageReactionRemove", onReaction("reactionRemoved"));
 
   // Role added/removed + nickname/timeout/boost (all via guildMemberUpdate)
   client.on("guildMemberUpdate", (oldMember, newMember) => {
@@ -379,6 +390,10 @@ export function registerActionEventListeners(client: Client): void {
       channelId: thread.id,
       channelName: thread.name,
       channelMention: `<#${thread.id}>`,
+      // The thread IS the context channel, so a channel filter would never
+      // match anything a user could pick. Carry the parent so
+      // "only threads under #support" is expressible.
+      parentChannelId: thread.parentId ?? undefined,
       memberCount: thread.guild.memberCount,
       timestamp: new Date().toISOString(),
       extra: {
diff --git a/apps/bot/src/features/automation/system/executor.ts b/apps/bot/src/features/automation/system/executor.ts
index 6857738a..f81ac029 100644
--- a/apps/bot/src/features/automation/system/executor.ts
+++ b/apps/bot/src/features/automation/system/executor.ts
@@ -46,32 +46,60 @@ function checkRateLimit(guildId: string, eventType: string): boolean {
 
 // --- Condition matching ---
 
+/**
+ * Trigger filters FAIL CLOSED: a configured filter the event context cannot
+ * answer means the rule does not fire.
+ *
+ * These guards used to read `conditions.excludeRoleIds?.length &&
+ * context.member`, which silently *skipped* an unanswerable filter. The rule
+ * then fired on exactly the users and channels it was configured to exclude —
+ * "exclude @Staff" on a Member Banned rule announced every staff ban, because
+ * a ban context carries no member — while the dashboard counted the filter as
+ * active. An exclusion that cannot be evaluated is not a permission to
+ * proceed; it is a reason to stop.
+ *
+ * The editor is event-aware (EVENT_CONDITION_SUPPORT) so new rules cannot be
+ * built with a filter their trigger can never evaluate.
+ */
 function matchesConditions(
   conditions: ActionConditions,
   context: EventContext,
 ): boolean {
-  // Include filters: if specified, context must match
-  if (conditions.channelIds?.length && context.channelId) {
-    if (!conditions.channelIds.includes(context.channelId)) return false;
+  // Channel filters test the parent too. On threadCreated the context channel
+  // is the brand-new thread, whose id the user cannot possibly have picked in
+  // the editor; the parent is the channel they actually chose.
+  const channelIds = [context.channelId, context.parentChannelId].filter(
+    (id): id is string => !!id,
+  );
+
+  // Include filters: the context must carry the datum AND match it.
+  if (conditions.channelIds?.length) {
+    if (channelIds.length === 0) return false;
+    if (!channelIds.some((id) => conditions.channelIds!.includes(id))) return false;
   }
-  if (conditions.userIds?.length && context.userId) {
+  if (conditions.userIds?.length) {
+    if (!context.userId) return false;
     if (!conditions.userIds.includes(context.userId)) return false;
   }
-  if (conditions.roleIds?.length && context.member) {
+  if (conditions.roleIds?.length) {
+    if (!context.member) return false;
     const hasMatchingRole = conditions.roleIds.some((id) =>
       context.member!.roles.cache.has(id),
     );
     if (!hasMatchingRole) return false;
   }
 
-  // Exclude filters: if matched, skip
-  if (conditions.excludeChannelIds?.length && context.channelId) {
-    if (conditions.excludeChannelIds.includes(context.channelId)) return false;
+  // Exclude filters: an unanswerable exclusion cannot be cleared, so it blocks.
+  if (conditions.excludeChannelIds?.length) {
+    if (channelIds.length === 0) return false;
+    if (channelIds.some((id) => conditions.excludeChannelIds!.includes(id))) return false;
   }
-  if (conditions.excludeUserIds?.length && context.userId) {
+  if (conditions.excludeUserIds?.length) {
+    if (!context.userId) return false;
     if (conditions.excludeUserIds.includes(context.userId)) return false;
   }
-  if (conditions.excludeRoleIds?.length && context.member) {
+  if (conditions.excludeRoleIds?.length) {
+    if (!context.member) return false;
     const hasExcludedRole = conditions.excludeRoleIds.some((id) =>
       context.member!.roles.cache.has(id),
     );
@@ -111,9 +139,21 @@ function evaluateCondition(
   condition: StepConditionConfig,
   context: EventContext,
 ): boolean {
-  const actual = getContextValue(condition.field, context);
   const expected = condition.value;
 
+  // Role operators are answered entirely by the member's roles — they never
+  // consume `condition.field`. Checking the field first meant the canonical
+  // "if member has @Verified" branch always took the else path, because the
+  // field defaults to channelId and memberJoin never populates one.
+  if (condition.operator === "hasRole") {
+    return context.member?.roles.cache.has(expected) ?? false;
+  }
+  if (condition.operator === "notHasRole") {
+    if (!context.member) return false;
+    return !context.member.roles.cache.has(expected);
+  }
+
+  const actual = getContextValue(condition.field, context);
   if (actual === undefined || actual === null) return false;
 
   const actualStr = String(actual);
@@ -137,10 +177,6 @@ function evaluateCondition(
       return Number(actual) > Number(expected);
     case "lessThan":
       return Number(actual) < Number(expected);
-    case "hasRole":
-      return context.member?.roles.cache.has(expected) ?? false;
-    case "notHasRole":
-      return !(context.member?.roles.cache.has(expected) ?? true);
     case "inList":
       return expected
         .split(",")
@@ -188,12 +224,12 @@ async function executeSteps(
         try {
           const executor = getExecutor(step.action.type as ActionType);
           if (!executor) {
-            logger.warn(
-              `Unknown action type: ${step.action.type} in rule "${rule.name}"`,
-            );
-          } else {
-            await executor(client, context, step.action);
+            // Must not fall through to the success log below: a rule
+            // referencing a removed action type would report a clean 100%
+            // success rate while doing nothing at all.
+            throw new Error(`Unknown action type: ${step.action.type}`);
           }
+          await executor(client, context, step.action);
           logExecution(rule, step.action.type, true, null).catch(() => {});
         } catch (error) {
           const err =
diff --git a/apps/bot/src/features/automation/system/registry.ts b/apps/bot/src/features/automation/system/registry.ts
index bbd63691..92708e92 100644
--- a/apps/bot/src/features/automation/system/registry.ts
+++ b/apps/bot/src/features/automation/system/registry.ts
@@ -32,13 +32,60 @@ function isValidEmoji(value: string): boolean {
   return UNICODE_EMOJI_REGEX.test(value);
 }
 
+/**
+ * Every executor THROWS rather than returning when it cannot do its job.
+ *
+ * processEvent cannot distinguish "returned because there was nothing to do"
+ * from "succeeded", so a silent return was written to the ActionLog as
+ * `success: true`. A moderator whose auto-role rule never fired saw
+ * "214 executions, 100% success" and had nothing to debug with. Throwing lets
+ * the caller's existing catch record the real reason.
+ */
+function required<T>(value: T | undefined | null, actionType: string, field: string): T {
+  if (value === undefined || value === null || value === "") {
+    throw new Error(`${actionType}: ${field} is required`);
+  }
+  return value;
+}
+
+/** Fetches a sendable text channel, or throws explaining which one failed. */
+async function sendableChannel(client: Client, channelId: string, actionType: string) {
+  const channel = await client.channels.fetch(channelId).catch(() => null);
+  if (!channel?.isTextBased() || !("send" in channel)) {
+    throw new Error(
+      `${actionType}: channel ${channelId} is missing, not a text channel, or not visible to the bot`,
+    );
+  }
+  return channel;
+}
+
+/**
+ * Resolves the member to act on. Reaction, ban and message contexts often
+ * carry no member object, which is why addRole/removeRole silently did nothing
+ * on the single most common automation people build ("react here, get a role").
+ */
+async function resolveMember(client: Client, ctx: EventContext, actionType: string) {
+  if (ctx.member) return ctx.member;
+  if (!ctx.userId || !ctx.guildId) {
+    throw new Error(`${actionType}: no member in context and no user/guild to resolve one from`);
+  }
+  try {
+    const guild = await client.guilds.fetch(ctx.guildId);
+    return await guild.members.fetch(ctx.userId);
+  } catch (err) {
+    throw new Error(
+      `${actionType}: could not resolve member ${ctx.userId} in guild ${ctx.guildId} (${err instanceof Error ? err.message : String(err)})`,
+    );
+  }
+}
+
 const executors = new Map<ActionType, ActionExecutor>();
 
 executors.set("sendMessage", async (client, ctx, config) => {
-  if (!config.channelId || !config.message) return;
-  const channel = await client.channels.fetch(config.channelId);
-  if (!channel?.isTextBased() || !("send" in channel)) return;
-  const resolved = resolveTemplate(config.message, ctx);
+  const channelId = required(config.channelId, "sendMessage", "channelId");
+  const message = required(config.message, "sendMessage", "message");
+  const channel = await sendableChannel(client, channelId, "sendMessage");
+  const resolved = resolveTemplate(message, ctx);
   await channel.send({
     content: resolved,
     allowedMentions: { users: ctx.userId ? [ctx.userId] : [] },
@@ -46,56 +93,55 @@ executors.set("sendMessage", async (client, ctx, config) => {
 });
 
 executors.set("sendEmbed", async (client, ctx, config) => {
-  if (!config.channelId || !config.embed) return;
-  const channel = await client.channels.fetch(config.channelId);
-  if (!channel?.isTextBased() || !("send" in channel)) return;
+  const channelId = required(config.channelId, "sendEmbed", "channelId");
+  const embedConfig = required(config.embed, "sendEmbed", "embed");
+  const channel = await sendableChannel(client, channelId, "sendEmbed");
 
   const embed = new EmbedBuilder().setTimestamp();
-  if (config.embed.title) {
-    embed.setTitle(resolveTemplate(config.embed.title, ctx));
+  if (embedConfig.title) {
+    embed.setTitle(resolveTemplate(embedConfig.title, ctx));
   }
-  if (config.embed.description) {
-    embed.setDescription(resolveTemplate(config.embed.description, ctx));
+  if (embedConfig.description) {
+    embed.setDescription(resolveTemplate(embedConfig.description, ctx));
   }
-  if (config.embed.color !== undefined) {
-    embed.setColor(config.embed.color);
+  if (embedConfig.color !== undefined) {
+    embed.setColor(embedConfig.color);
   }
-  if (config.embed.footer) {
-    embed.setFooter({ text: resolveTemplate(config.embed.footer, ctx) });
+  if (embedConfig.footer) {
+    embed.setFooter({ text: resolveTemplate(embedConfig.footer, ctx) });
   }
   await channel.send({ embeds: [embed] });
 });
 
 executors.set("sendDM", async (client, ctx, config) => {
-  if (!config.message) return;
-  const resolved = resolveTemplate(config.message, ctx);
-  try {
-    // Prefer ctx.member.user if available, otherwise fetch the user directly
-    if (ctx.member) {
-      await ctx.member.user.send(resolved);
-    } else if (ctx.userId) {
-      const user = await client.users.fetch(ctx.userId);
-      await user.send(resolved);
-    }
-  } catch (err) {
-    logger.warn(`sendDM failed for user ${ctx.userId ?? "unknown"}: ${err instanceof Error ? err.message : String(err)}`);
+  const message = required(config.message, "sendDM", "message");
+  const resolved = resolveTemplate(message, ctx);
+  // A closed DM is a real, reportable failure — the moderator needs to know
+  // their welcome DM is not arriving, not see it logged as a success.
+  if (ctx.member) {
+    await ctx.member.user.send(resolved);
+    return;
   }
+  const userId = required(ctx.userId, "sendDM", "a user to DM");
+  const user = await client.users.fetch(userId);
+  await user.send(resolved);
 });
 
-executors.set("addRole", async (_client, ctx, config) => {
-  if (!ctx.member || !config.roleId) return;
-  await ctx.member.roles.add(config.roleId);
+executors.set("addRole", async (client, ctx, config) => {
+  const roleId = required(config.roleId, "addRole", "roleId");
+  const member = await resolveMember(client, ctx, "addRole");
+  await member.roles.add(roleId);
 });
 
-executors.set("removeRole", async (_client, ctx, config) => {
-  if (!ctx.member || !config.roleId) return;
-  await ctx.member.roles.remove(config.roleId);
+executors.set("removeRole", async (client, ctx, config) => {
+  const roleId = required(config.roleId, "removeRole", "roleId");
+  const member = await resolveMember(client, ctx, "removeRole");
+  await member.roles.remove(roleId);
 });
 
 executors.set("logToChannel", async (client, ctx, config) => {
-  if (!config.channelId) return;
-  const channel = await client.channels.fetch(config.channelId);
-  if (!channel?.isTextBased() || !("send" in channel)) return;
+  const channelId = required(config.channelId, "logToChannel", "channelId");
+  const channel = await sendableChannel(client, channelId, "logToChannel");
 
   const eventInfo = EVENT_TYPES[ctx.eventType];
   const embed = new EmbedBuilder()
@@ -155,28 +201,60 @@ async function isPrivateHost(hostname: string): Promise<boolean> {
   }
 }
 
-executors.set("sendWebhook", async (_client, ctx, config) => {
-  if (!config.webhook?.url) return;
+const MAX_WEBHOOK_REDIRECTS = 3;
+const MAX_WEBHOOK_RESPONSE_BYTES = 64 * 1024;
 
+/** Throws unless the URL is https and does not resolve to a private address. */
+async function assertSafeWebhookTarget(raw: string): Promise<URL> {
   let url: URL;
   try {
-    url = new URL(config.webhook.url);
+    url = new URL(raw);
   } catch {
-    logger.warn(`Invalid webhook URL in action config: ${config.webhook.url}`);
-    return;
+    throw new Error(`sendWebhook: "${raw}" is not a valid URL`);
   }
-
   if (url.protocol !== "https:") {
-    logger.warn(`Webhook URL must use HTTPS: ${config.webhook.url}`);
-    return;
+    throw new Error(`sendWebhook: URL must use HTTPS, got ${url.protocol.replace(":", "")}`);
   }
-
   if (await isPrivateHost(url.hostname)) {
-    logger.warn(`Webhook URL points to private/internal host: ${url.hostname}`);
+    throw new Error(`sendWebhook: ${url.hostname} resolves to a private/internal address`);
+  }
+  return url;
+}
+
+/**
+ * Reads at most `MAX_WEBHOOK_RESPONSE_BYTES` and then cancels the stream.
+ * `await response.text()` buffers whatever the remote chooses to send, so a
+ * hostile or broken endpoint could stream until the bot ran out of memory. We
+ * only read at all to release the connection; the content is never used.
+ */
+async function drainCapped(response: { body?: unknown; text?: () => Promise<string> }): Promise<void> {
+  const body = response.body as
+    | { getReader(): { read(): Promise<{ done: boolean; value?: { length: number } }>; cancel(): unknown } }
+    | null
+    | undefined;
+  if (!body?.getReader) {
+    await response.text?.();
     return;
   }
+  const reader = body.getReader();
+  let read = 0;
+  try {
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      read += value?.length ?? 0;
+      if (read >= MAX_WEBHOOK_RESPONSE_BYTES) break;
+    }
+  } finally {
+    await reader.cancel();
+  }
+}
+
+executors.set("sendWebhook", async (_client, ctx, config) => {
+  const rawUrl = required(config.webhook?.url, "sendWebhook", "webhook.url");
+  let url = await assertSafeWebhookTarget(rawUrl);
 
-  let body = config.webhook.bodyTemplate ?? JSON.stringify({
+  let body = config.webhook?.bodyTemplate ?? JSON.stringify({
     event: ctx.eventType,
     guild: ctx.guildName,
     user: ctx.userName,
@@ -203,7 +281,7 @@ executors.set("sendWebhook", async (_client, ctx, config) => {
   ]);
   const ALLOWED_PREFIX = "x-fluxcore-";
 
-  const userHeaders = config.webhook.headers ?? {};
+  const userHeaders = config.webhook?.headers ?? {};
   const headers: Record<string, string> = {
     "Content-Type": "application/json",
   };
@@ -219,49 +297,69 @@ executors.set("sendWebhook", async (_client, ctx, config) => {
     }
   }
 
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), 5000);
+  // Redirects are followed BY HAND so every hop is re-checked against the
+  // private-address rules. With fetch's automatic following, the SSRF guard ran
+  // once against the original hostname and a public host answering
+  // "302 -> http://169.254.169.254/" walked straight into the cloud metadata
+  // service.
+  for (let hop = 0; ; hop++) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
+    let response: Response;
+    try {
+      response = await fetch(url.toString(), {
+        method: config.webhook?.method ?? "POST",
+        headers,
+        body,
+        signal: controller.signal,
+        redirect: "manual",
+      });
+    } finally {
+      clearTimeout(timeout);
+    }
 
-  try {
-    const response = await fetch(config.webhook.url, {
-      method: config.webhook.method ?? "POST",
-      headers,
-      body,
-      signal: controller.signal,
-    });
-    // Consume response body to release the connection
-    await response.text();
-  } finally {
-    clearTimeout(timeout);
+    if (response.status >= 300 && response.status < 400) {
+      const location = response.headers.get("location");
+      await drainCapped(response);
+      if (!location) {
+        throw new Error(`sendWebhook: ${response.status} redirect with no Location header`);
+      }
+      if (hop >= MAX_WEBHOOK_REDIRECTS) {
+        throw new Error(`sendWebhook: too many redirects (>${MAX_WEBHOOK_REDIRECTS})`);
+      }
+      url = await assertSafeWebhookTarget(new URL(location, url).toString());
+      continue;
+    }
+
+    await drainCapped(response);
+    if (response.status < 200 || response.status >= 300) {
+      throw new Error(`sendWebhook: ${url.hostname} responded ${response.status}`);
+    }
+    return;
   }
 });
 
 // --- Set Nickname ---
 
 executors.set("setNickname", async (client, ctx, config) => {
-  if (!config.nickname) return;
-  try {
-    // Fetch member from guild if not in context
-    let member = ctx.member;
-    if (!member && ctx.userId && ctx.guildId) {
-      const guild = await client.guilds.fetch(ctx.guildId);
-      member = await guild.members.fetch(ctx.userId);
-    }
-    if (!member) return;
-    const resolved = resolveTemplate(config.nickname, ctx);
-    await member.setNickname(resolved.slice(0, 32));
-  } catch (err) {
-    logger.warn(`setNickname failed for user ${ctx.userId ?? "unknown"}: ${err instanceof Error ? err.message : String(err)}`);
-  }
+  const nickname = required(config.nickname, "setNickname", "nickname");
+  const member = await resolveMember(client, ctx, "setNickname");
+  const resolved = resolveTemplate(nickname, ctx);
+  await member.setNickname(resolved.slice(0, 32));
 });
 
 // --- Create Thread ---
 
 executors.set("createThread", async (client, ctx, config) => {
-  if (!config.channelId || !config.threadName) return;
-  const channel = await client.channels.fetch(config.channelId);
-  if (!channel?.isTextBased() || !("threads" in channel)) return;
-  const resolved = resolveTemplate(config.threadName, ctx);
+  const channelId = required(config.channelId, "createThread", "channelId");
+  const threadName = required(config.threadName, "createThread", "threadName");
+  const channel = await client.channels.fetch(channelId).catch(() => null);
+  if (!channel?.isTextBased() || !("threads" in channel)) {
+    throw new Error(
+      `createThread: channel ${channelId} is missing, not visible to the bot, or does not support threads`,
+    );
+  }
+  const resolved = resolveTemplate(threadName, ctx);
   await (channel as TextChannel).threads.create({
     name: resolved.slice(0, 100),
   });
@@ -270,23 +368,18 @@ executors.set("createThread", async (client, ctx, config) => {
 // --- Add Reaction ---
 
 executors.set("addReaction", async (client, ctx, config) => {
-  if (!config.emoji || !ctx.extra?.["message.id"] || !ctx.channelId) return;
-  if (!isValidEmoji(config.emoji)) {
-    logger.warn(
-      `addReaction skipped: invalid emoji "${config.emoji}" for guild ${ctx.guildId ?? "unknown"}`,
-    );
-    return;
+  const emoji = required(config.emoji, "addReaction", "emoji");
+  if (!isValidEmoji(emoji)) {
+    throw new Error(`addReaction: "${emoji}" is not a valid unicode or custom emoji`);
   }
-  const channel = await client.channels.fetch(ctx.channelId);
-  if (!channel?.isTextBased() || !("messages" in channel)) return;
-  try {
-    const message = await (channel as TextChannel).messages.fetch(
-      ctx.extra["message.id"],
-    );
-    await message.react(config.emoji);
-  } catch (err) {
-    logger.warn(`addReaction failed (emoji: ${config.emoji}, message: ${ctx.extra?.["message.id"] ?? "unknown"}): ${err instanceof Error ? err.message : String(err)}`);
+  const messageId = required(ctx.extra?.["message.id"], "addReaction", "a triggering message");
+  const channelId = required(ctx.channelId, "addReaction", "a channel in the event context");
+  const channel = await client.channels.fetch(channelId).catch(() => null);
+  if (!channel?.isTextBased() || !("messages" in channel)) {
+    throw new Error(`addReaction: channel ${channelId} is missing or not visible to the bot`);
   }
+  const message = await (channel as TextChannel).messages.fetch(messageId);
+  await message.react(emoji);
 });
 
 export function getExecutor(actionType: ActionType): ActionExecutor | undefined {
diff --git a/apps/bot/src/shared/client/ExtendedClient.ts b/apps/bot/src/shared/client/ExtendedClient.ts
index a8e4ffaf..313a3ae0 100644
--- a/apps/bot/src/shared/client/ExtendedClient.ts
+++ b/apps/bot/src/shared/client/ExtendedClient.ts
@@ -1,4 +1,4 @@
-import { Client, Collection, GatewayIntentBits } from "discord.js";
+import { Client, Collection, GatewayIntentBits, Partials } from "discord.js";
 import type { Command } from "@fluxcore/types";
 
 export class ExtendedClient extends Client {
@@ -15,6 +15,18 @@ export class ExtendedClient extends Client {
         GatewayIntentBits.MessageContent, // Privileged: required for message content access
         GatewayIntentBits.GuildMessageReactions, // Required for reaction events
       ],
+      // Without these, discord.js silently DROPS any event whose primary
+      // structure is not already in cache. The bot only caches messages it has
+      // seen since its last restart, so reactionAdded / reactionRemoved /
+      // messageDeleted never fired for an older message — which breaks every
+      // reaction-role automation attached to a pinned rules message, with no
+      // error anywhere. Handlers that read a partial must fetch it first.
+      partials: [
+        Partials.Message,
+        Partials.Reaction,
+        Partials.Channel,
+        Partials.User,
+      ],
     });
   }
 }
diff --git a/apps/bot/tests/features/automation/system/eventBridge-partials.test.ts b/apps/bot/tests/features/automation/system/eventBridge-partials.test.ts
new file mode 100644
index 00000000..6b378ba5
--- /dev/null
+++ b/apps/bot/tests/features/automation/system/eventBridge-partials.test.ts
@@ -0,0 +1,159 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("@fluxcore/config", () => ({
+  config: { token: "t", clientId: "c", guildId: undefined, logLevel: "info" },
+}));
+
+vi.mock("@fluxcore/utils", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("@fluxcore/utils")>();
+  return {
+    ...actual,
+    logger: { warn: vi.fn(), error: vi.fn(), info: vi.fn(), debug: vi.fn() },
+  };
+});
+
+const mockProcessEvent = vi.fn().mockResolvedValue(undefined);
+vi.mock("../../../../src/features/automation/system/executor.js", () => ({
+  processEvent: (...args: unknown[]) => mockProcessEvent(...args),
+}));
+
+const mockGetRulesForEvent = vi.fn().mockReturnValue([{ id: 1 }]);
+vi.mock("@fluxcore/systems/actions/cache", () => ({
+  getRulesForEvent: (...args: unknown[]) => mockGetRulesForEvent(...args),
+}));
+
+const { registerActionEventListeners } = await import(
+  "../../../../src/features/automation/system/eventBridge.js"
+);
+
+/** Captures the handlers registered via client.on so tests can invoke them. */
+function fakeClient() {
+  const handlers = new Map<string, (...args: unknown[]) => unknown>();
+  return {
+    client: { on: (name: string, fn: (...args: unknown[]) => unknown) => handlers.set(name, fn) },
+    handlers,
+  };
+}
+
+function partialReaction(overrides: Record<string, unknown> = {}) {
+  return {
+    partial: true,
+    fetch: vi.fn().mockResolvedValue(undefined),
+    emoji: { toString: () => "🎉", name: "tada" },
+    message: {
+      guildId: "g1",
+      guild: { name: "G", memberCount: 5 },
+      channelId: "c1",
+      channel: { name: "general" },
+      id: "m1",
+      url: "https://discord.com/x",
+    },
+    ...overrides,
+  };
+}
+
+/**
+ * Partials are now enabled on the client, so reaction events arrive for
+ * messages the bot has not cached. If the bridge does not fetch them first it
+ * builds a context out of nulls — or drops the event entirely — and every
+ * reaction automation on an older message stays silently broken.
+ */
+describe("eventBridge resolves partials before building a context", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockGetRulesForEvent.mockReturnValue([{ id: 1 }]);
+  });
+
+  it("fetches a partial reaction before processing reactionAdded", async () => {
+    const { client, handlers } = fakeClient();
+    registerActionEventListeners(client as never);
+    const reaction = partialReaction();
+
+    await handlers.get("messageReactionAdd")!(reaction, { id: "u1", bot: false, username: "ada" });
+
+    expect(reaction.fetch).toHaveBeenCalled();
+    expect(mockProcessEvent).toHaveBeenCalled();
+  });
+
+  it("fetches a partial user so the context carries a real username", async () => {
+    const { client, handlers } = fakeClient();
+    registerActionEventListeners(client as never);
+    const user = { id: "u1", bot: false, partial: true, fetch: vi.fn().mockResolvedValue({ id: "u1", username: "ada", tag: "ada#1" }) };
+
+    await handlers.get("messageReactionAdd")!(partialReaction(), user);
+
+    expect(user.fetch).toHaveBeenCalled();
+  });
+
+  it("drops the event rather than throwing when the message is gone", async () => {
+    const { client, handlers } = fakeClient();
+    registerActionEventListeners(client as never);
+    const reaction = partialReaction({
+      fetch: vi.fn().mockRejectedValue(new Error("Unknown Message")),
+    });
+
+    await expect(
+      handlers.get("messageReactionAdd")!(reaction, { id: "u1", bot: false }),
+    ).resolves.not.toThrow();
+    expect(mockProcessEvent).not.toHaveBeenCalled();
+  });
+
+  it("still processes reactionRemoved for a partial reaction", async () => {
+    const { client, handlers } = fakeClient();
+    registerActionEventListeners(client as never);
+    const reaction = partialReaction();
+
+    await handlers.get("messageReactionRemove")!(reaction, { id: "u1", bot: false });
+
+    expect(reaction.fetch).toHaveBeenCalled();
+    expect(mockProcessEvent).toHaveBeenCalled();
+  });
+
+  // A deleted message cannot be fetched back, so the bridge must not treat a
+  // null author as "this is a bot, skip it" — that would drop every
+  // messageDeleted event for an uncached message.
+  it("processes messageDeleted for a partial message with no author", async () => {
+    const { client, handlers } = fakeClient();
+    registerActionEventListeners(client as never);
+
+    await handlers.get("messageDelete")!({
+      partial: true,
+      guildId: "g1",
+      guild: { name: "G", memberCount: 5 },
+      channelId: "c1",
+      channel: { name: "general" },
+      id: "m1",
+      author: null,
+      content: null,
+    });
+
+    expect(mockProcessEvent).toHaveBeenCalled();
+  });
+});
+
+describe("eventBridge threadCreated matches on the parent channel", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockGetRulesForEvent.mockReturnValue([{ id: 1 }]);
+  });
+
+  // context.channelId is the NEW thread, so "only threads under #support"
+  // could never match. The parent has to travel with the context for a channel
+  // filter on threadCreated to mean anything.
+  it("carries the parent channel id in the event context", async () => {
+    const { client, handlers } = fakeClient();
+    registerActionEventListeners(client as never);
+
+    await handlers.get("threadCreate")!({
+      guildId: "g1",
+      guild: { name: "G", memberCount: 5 },
+      id: "t1",
+      name: "help",
+      ownerId: "u1",
+      parentId: "parent-1",
+    });
+
+    const ctx = mockProcessEvent.mock.calls[0][1];
+    expect(ctx.parentChannelId).toBe("parent-1");
+  });
+});
diff --git a/apps/bot/tests/features/automation/system/executor-steps.test.ts b/apps/bot/tests/features/automation/system/executor-steps.test.ts
new file mode 100644
index 00000000..4215adeb
--- /dev/null
+++ b/apps/bot/tests/features/automation/system/executor-steps.test.ts
@@ -0,0 +1,238 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("@fluxcore/config", () => ({
+  config: { token: "t", clientId: "c", guildId: undefined, logLevel: "info" },
+}));
+
+const mockGetGuildSettingsOrDefault = vi.fn().mockReturnValue({ globalEnabled: true, maxRules: 25 });
+vi.mock("@fluxcore/systems/actions/config", () => ({
+  getGuildSettingsOrDefault: (...a: unknown[]) => mockGetGuildSettingsOrDefault(...a),
+}));
+
+const mockGetRulesForEvent = vi.fn().mockReturnValue([]);
+vi.mock("@fluxcore/systems/actions/cache", () => ({
+  getRulesForEvent: (...a: unknown[]) => mockGetRulesForEvent(...a),
+}));
+
+const mockLogExecution = vi.fn().mockResolvedValue(undefined);
+vi.mock("@fluxcore/systems/actions/persistence", () => ({
+  logExecution: (...a: unknown[]) => mockLogExecution(...a),
+}));
+
+/** Records which action ran, in order, so branch/order assertions are exact. */
+const ran: string[] = [];
+const mockExecutor = vi.fn(async (_c: unknown, _ctx: unknown, config: { type: string; message?: string }) => {
+  ran.push(config.message ?? config.type);
+});
+vi.mock("../../../../src/features/automation/system/registry.js", () => ({
+  getExecutor: vi.fn((type: string) => (type === "unknownAction" ? null : mockExecutor)),
+}));
+
+const { processEvent } = await import(
+  "../../../../src/features/automation/system/executor.js"
+);
+
+const ctx = {
+  eventType: "memberJoin" as const,
+  guildId: "g1",
+  guildName: "G",
+  userId: "u1",
+  userName: "ada",
+  channelId: "c1",
+  channelName: "general",
+  memberCount: 42,
+  timestamp: new Date().toISOString(),
+};
+
+function action(id: string, message: string, next: string | null) {
+  return { id, type: "action", action: { type: "sendMessage", message }, next };
+}
+
+function rule(steps: unknown[], entryStepId: string) {
+  return [{ name: "graph", enabled: true, conditions: {}, actions: [], steps, entryStepId }];
+}
+
+/**
+ * The v2 step graph is what the canvas actually saves once a rule has any
+ * condition or delay, and the executor prefers it over the flat action list —
+ * yet none of it was covered. These are the paths a user's branching workflow
+ * depends on.
+ */
+describe("executor — v2 step graph", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    ran.length = 0;
+    mockGetGuildSettingsOrDefault.mockReturnValue({ globalEnabled: true, maxRules: 25 });
+  });
+
+  it("runs steps in `next` order, not array order", async () => {
+    mockGetRulesForEvent.mockReturnValueOnce(
+      rule(
+        [action("a", "first", "c"), action("b", "third", null), action("c", "second", "b")],
+        "a",
+      ),
+    );
+
+    await processEvent({} as never, ctx);
+
+    expect(ran).toEqual(["first", "second", "third"]);
+  });
+
+  it("prefers the step graph over the flat action list", async () => {
+    mockGetRulesForEvent.mockReturnValueOnce([
+      {
+        name: "both",
+        enabled: true,
+        conditions: {},
+        actions: [{ type: "sendMessage", message: "legacy" }],
+        steps: [action("a", "graph", null)],
+        entryStepId: "a",
+      },
+    ]);
+
+    await processEvent({} as never, ctx);
+
+    expect(ran).toEqual(["graph"]);
+  });
+
+  it("takes the then-branch when the condition matches", async () => {
+    mockGetRulesForEvent.mockReturnValueOnce(
+      rule(
+        [
+          { id: "q", type: "condition", condition: { field: "channelName", operator: "equals", value: "general" }, thenNext: "yes", elseNext: "no" },
+          action("yes", "matched", null),
+          action("no", "missed", null),
+        ],
+        "q",
+      ),
+    );
+
+    await processEvent({} as never, ctx);
+
+    expect(ran).toEqual(["matched"]);
+  });
+
+  it("takes the else-branch when it does not", async () => {
+    mockGetRulesForEvent.mockReturnValueOnce(
+      rule(
+        [
+          { id: "q", type: "condition", condition: { field: "channelName", operator: "equals", value: "other" }, thenNext: "yes", elseNext: "no" },
+          action("yes", "matched", null),
+          action("no", "missed", null),
+        ],
+        "q",
+      ),
+    );
+
+    await processEvent({} as never, ctx);
+
+    expect(ran).toEqual(["missed"]);
+  });
+
+  it("stops cleanly on a null branch", async () => {
+    mockGetRulesForEvent.mockReturnValueOnce(
+      rule(
+        [{ id: "q", type: "condition", condition: { field: "channelName", operator: "equals", value: "nope" }, thenNext: "yes", elseNext: null }, action("yes", "matched", null)],
+        "q",
+      ),
+    );
+
+    await processEvent({} as never, ctx);
+
+    expect(ran).toEqual([]);
+  });
+
+  it("caps a cyclic graph instead of looping forever", async () => {
+    mockGetRulesForEvent.mockReturnValueOnce(
+      rule([action("a", "loop", "b"), action("b", "loop", "a")], "a"),
+    );
+
+    await processEvent({} as never, ctx);
+
+    // MAX_STEP_ITERATIONS is 20 and every iteration here is an action.
+    expect(ran.length).toBe(20);
+  });
+
+  it("stops when `next` points at a step that does not exist", async () => {
+    mockGetRulesForEvent.mockReturnValueOnce(
+      rule([action("a", "only", "ghost")], "a"),
+    );
+
+    await expect(processEvent({} as never, ctx)).resolves.not.toThrow();
+    expect(ran).toEqual(["only"]);
+  });
+
+  it("keeps going after one action fails, and logs the failure", async () => {
+    mockExecutor.mockRejectedValueOnce(new Error("boom"));
+    mockGetRulesForEvent.mockReturnValueOnce(
+      rule([action("a", "bad", "b"), action("b", "good", null)], "a"),
+    );
+
+    await processEvent({} as never, ctx);
+
+    expect(ran).toEqual(["good"]);
+    expect(mockLogExecution).toHaveBeenCalledWith(
+      expect.anything(), "sendMessage", false, "boom",
+    );
+  });
+
+  it("runs a delay step and continues", async () => {
+    vi.useFakeTimers();
+    mockGetRulesForEvent.mockReturnValueOnce(
+      rule([{ id: "d", type: "delay", delayMs: 1000, next: "a" }, action("a", "after", null)], "d"),
+    );
+
+    const done = processEvent({} as never, ctx);
+    await vi.advanceTimersByTimeAsync(1000);
+    await done;
+    vi.useRealTimers();
+
+    expect(ran).toEqual(["after"]);
+  });
+
+  it("does not run the graph without an entry step", async () => {
+    mockGetRulesForEvent.mockReturnValueOnce([
+      { name: "no-entry", enabled: true, conditions: {}, actions: [], steps: [action("a", "x", null)] },
+    ]);
+
+    await processEvent({} as never, ctx);
+
+    expect(ran).toEqual([]);
+  });
+
+  it("skips the whole graph when the rule's trigger filters do not match", async () => {
+    mockGetRulesForEvent.mockReturnValueOnce([
+      {
+        name: "filtered",
+        enabled: true,
+        conditions: { channelIds: ["somewhere-else"] },
+        actions: [],
+        steps: [action("a", "x", null)],
+        entryStepId: "a",
+      },
+    ]);
+
+    await processEvent({} as never, ctx);
+
+    expect(ran).toEqual([]);
+  });
+
+  it("logs each condition evaluation with its outcome", async () => {
+    mockGetRulesForEvent.mockReturnValueOnce(
+      rule(
+        [{ id: "q", type: "condition", condition: { field: "channelName", operator: "equals", value: "general" }, thenNext: null, elseNext: null }],
+        "q",
+      ),
+    );
+
+    await processEvent({} as never, ctx);
+
+    expect(mockLogExecution).toHaveBeenCalledWith(
+      expect.anything(),
+      "condition:channelName",
+      true,
+      null,
+      expect.objectContaining({ result: true }),
+    );
+  });
+});
diff --git a/apps/bot/tests/features/automation/system/executor.test.ts b/apps/bot/tests/features/automation/system/executor.test.ts
index 49f4567f..b5d83a34 100644
--- a/apps/bot/tests/features/automation/system/executor.test.ts
+++ b/apps/bot/tests/features/automation/system/executor.test.ts
@@ -214,3 +214,290 @@ describe("action executor - processEvent", () => {
     expect(mockSendMessageExecutor).toHaveBeenCalledTimes(2);
   });
 });
+
+/**
+ * Filters used to be guarded on the presence of their own datum
+ * (`conditions.excludeRoleIds?.length && context.member`), so a filter the
+ * event context could not answer was skipped rather than failed. The rule then
+ * fired on exactly the users and channels it had been configured to skip, while
+ * the dashboard showed the filter as active. Every case below is a rule that
+ * must NOT fire.
+ */
+describe("action executor - filters fail closed", () => {
+  const memberlessContext = {
+    eventType: "memberBanned" as const,
+    guildId: "guild-123",
+    guildName: "Test Guild",
+    userId: "user-456",
+    userName: "TestUser",
+    userTag: "TestUser#0001",
+    userMention: "<@user-456>",
+    memberCount: 100,
+    timestamp: new Date().toISOString(),
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockGetGuildSettingsOrDefault.mockReturnValue({
+      globalEnabled: true,
+      maxRules: 25,
+      logChannelId: null,
+    });
+  });
+
+  function ruleWith(conditions: Record<string, string[]>) {
+    return [
+      { name: "filtered", enabled: true, conditions, actions: [{ type: "sendMessage" }] },
+    ];
+  }
+
+  it("does not fire an exclude-role filter when the event carries no member", async () => {
+    mockGetRulesForEvent.mockReturnValueOnce(ruleWith({ excludeRoleIds: ["staff"] }));
+
+    await processEvent({} as never, memberlessContext);
+
+    expect(mockSendMessageExecutor).not.toHaveBeenCalled();
+  });
+
+  it("does not fire an include-role filter when the event carries no member", async () => {
+    mockGetRulesForEvent.mockReturnValueOnce(ruleWith({ roleIds: ["verified"] }));
+
+    await processEvent({} as never, memberlessContext);
+
+    expect(mockSendMessageExecutor).not.toHaveBeenCalled();
+  });
+
+  it("does not fire a channel filter when the event carries no channel", async () => {
+    mockGetRulesForEvent.mockReturnValueOnce(ruleWith({ channelIds: ["general"] }));
+
+    await processEvent({} as never, memberlessContext);
+
+    expect(mockSendMessageExecutor).not.toHaveBeenCalled();
+  });
+
+  it("does not fire an exclude-channel filter when the event carries no channel", async () => {
+    mockGetRulesForEvent.mockReturnValueOnce(ruleWith({ excludeChannelIds: ["general"] }));
+
+    await processEvent({} as never, memberlessContext);
+
+    expect(mockSendMessageExecutor).not.toHaveBeenCalled();
+  });
+
+  it("does not fire a user filter when the event carries no user", async () => {
+    mockGetRulesForEvent.mockReturnValueOnce(ruleWith({ userIds: ["someone"] }));
+
+    await processEvent({} as never, {
+      eventType: "channelCreated" as const,
+      guildId: "guild-123",
+      guildName: "Test Guild",
+      channelId: "channel-789",
+      memberCount: 100,
+      timestamp: new Date().toISOString(),
+    });
+
+    expect(mockSendMessageExecutor).not.toHaveBeenCalled();
+  });
+
+  it("still fires when the filter is satisfiable and matches", async () => {
+    const withMember = {
+      ...memberlessContext,
+      member: { roles: { cache: new Map([["verified", {}]]) } },
+    };
+    mockGetRulesForEvent.mockReturnValueOnce(ruleWith({ roleIds: ["verified"] }));
+
+    await processEvent({} as never, withMember as never);
+
+    expect(mockSendMessageExecutor).toHaveBeenCalled();
+  });
+
+  it("still skips when the filter is satisfiable and does not match", async () => {
+    const withMember = {
+      ...memberlessContext,
+      member: { roles: { cache: new Map([["other", {}]]) } },
+    };
+    mockGetRulesForEvent.mockReturnValueOnce(ruleWith({ roleIds: ["verified"] }));
+
+    await processEvent({} as never, withMember as never);
+
+    expect(mockSendMessageExecutor).not.toHaveBeenCalled();
+  });
+
+  it("leaves unfiltered rules alone", async () => {
+    mockGetRulesForEvent.mockReturnValueOnce(ruleWith({}));
+
+    await processEvent({} as never, memberlessContext);
+
+    expect(mockSendMessageExecutor).toHaveBeenCalled();
+  });
+
+  // On threadCreated the context channel is the brand-new thread, so a channel
+  // filter could only ever match an id the user has no way to know. The parent
+  // is what they actually picked in the editor.
+  it("matches a channel filter against the parent channel", async () => {
+    const threadCtx = {
+      eventType: "threadCreated" as const,
+      guildId: "guild-123",
+      guildName: "Test Guild",
+      channelId: "thread-new",
+      parentChannelId: "support",
+      memberCount: 100,
+      timestamp: new Date().toISOString(),
+    };
+    mockGetRulesForEvent.mockReturnValueOnce(ruleWith({ channelIds: ["support"] }));
+
+    await processEvent({} as never, threadCtx);
+
+    expect(mockSendMessageExecutor).toHaveBeenCalled();
+  });
+
+  it("excludes on the parent channel too", async () => {
+    const threadCtx = {
+      eventType: "threadCreated" as const,
+      guildId: "guild-123",
+      guildName: "Test Guild",
+      channelId: "thread-new",
+      parentChannelId: "support",
+      memberCount: 100,
+      timestamp: new Date().toISOString(),
+    };
+    mockGetRulesForEvent.mockReturnValueOnce(ruleWith({ excludeChannelIds: ["support"] }));
+
+    await processEvent({} as never, threadCtx);
+
+    expect(mockSendMessageExecutor).not.toHaveBeenCalled();
+  });
+});
+
+describe("action executor - the log tells the truth", () => {
+  const ctx = {
+    eventType: "memberJoin" as const,
+    guildId: "guild-123",
+    guildName: "Test Guild",
+    userId: "user-456",
+    memberCount: 100,
+    timestamp: new Date().toISOString(),
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockGetGuildSettingsOrDefault.mockReturnValue({ globalEnabled: true, maxRules: 25 });
+  });
+
+  // The step-mode branch warned about an unknown action type and then fell
+  // through to the success log, so a rule referencing a removed action type
+  // reported a clean 100% success rate forever.
+  it("does not log success for an unknown action type in step mode", async () => {
+    mockGetRulesForEvent.mockReturnValueOnce([
+      {
+        name: "unknown-step",
+        enabled: true,
+        conditions: {},
+        actions: [],
+        entryStepId: "s0",
+        steps: [{ id: "s0", type: "action", action: { type: "unknownAction" }, next: null }],
+      },
+    ]);
+
+    await processEvent({} as never, ctx);
+
+    expect(mockLogExecution).not.toHaveBeenCalledWith(
+      expect.anything(), expect.anything(), true, expect.anything(),
+    );
+  });
+
+  it("logs a failure for an unknown action type in step mode", async () => {
+    mockGetRulesForEvent.mockReturnValueOnce([
+      {
+        name: "unknown-step",
+        enabled: true,
+        conditions: {},
+        actions: [],
+        entryStepId: "s0",
+        steps: [{ id: "s0", type: "action", action: { type: "unknownAction" }, next: null }],
+      },
+    ]);
+
+    await processEvent({} as never, ctx);
+
+    expect(mockLogExecution).toHaveBeenCalledWith(
+      expect.anything(), "unknownAction", false, expect.stringMatching(/unknown action type/i),
+    );
+  });
+});
+
+/**
+ * Condition steps read `getContextValue(condition.field)` and bail when it is
+ * undefined — BEFORE looking at the operator. hasRole/notHasRole do not consume
+ * the field at all, so the canonical "if member has @Verified" branch always
+ * took the else path on memberJoin (whose context has no channelId, the
+ * default field).
+ */
+describe("action executor - role operators ignore the unrelated field", () => {
+  const memberWithRole = {
+    eventType: "memberJoin" as const,
+    guildId: "guild-123",
+    guildName: "Test Guild",
+    userId: "user-456",
+    memberCount: 100,
+    timestamp: new Date().toISOString(),
+    member: { roles: { cache: new Map([["verified", {}]]) } },
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockGetGuildSettingsOrDefault.mockReturnValue({ globalEnabled: true, maxRules: 25 });
+  });
+
+  function branchRule(operator: string) {
+    return [
+      {
+        name: "branch",
+        enabled: true,
+        conditions: {},
+        actions: [],
+        entryStepId: "cond",
+        steps: [
+          {
+            id: "cond",
+            type: "condition",
+            // channelId is the default field and memberJoin never populates it.
+            condition: { field: "channelId", operator, value: "verified" },
+            thenNext: "yes",
+            elseNext: null,
+          },
+          { id: "yes", type: "action", action: { type: "sendMessage" }, next: null },
+        ],
+      },
+    ];
+  }
+
+  it("takes the then-branch when the member has the role", async () => {
+    mockGetRulesForEvent.mockReturnValueOnce(branchRule("hasRole"));
+
+    await processEvent({} as never, memberWithRole as never);
+
+    expect(mockSendMessageExecutor).toHaveBeenCalled();
+  });
+
+  it("takes the else-branch when the member lacks the role", async () => {
+    mockGetRulesForEvent.mockReturnValueOnce(branchRule("hasRole"));
+
+    await processEvent({} as never, {
+      ...memberWithRole,
+      member: { roles: { cache: new Map() } },
+    } as never);
+
+    expect(mockSendMessageExecutor).not.toHaveBeenCalled();
+  });
+
+  it("notHasRole takes the then-branch when the member lacks the role", async () => {
+    mockGetRulesForEvent.mockReturnValueOnce(branchRule("notHasRole"));
+
+    await processEvent({} as never, {
+      ...memberWithRole,
+      member: { roles: { cache: new Map() } },
+    } as never);
+
+    expect(mockSendMessageExecutor).toHaveBeenCalled();
+  });
+});
diff --git a/apps/bot/tests/features/automation/system/registry-emoji.test.ts b/apps/bot/tests/features/automation/system/registry-emoji.test.ts
index ff4fe285..5cc6ad93 100644
--- a/apps/bot/tests/features/automation/system/registry-emoji.test.ts
+++ b/apps/bot/tests/features/automation/system/registry-emoji.test.ts
@@ -54,15 +54,17 @@ describe("addReaction emoji validation", () => {
     const client = mkClient(fetchSpy);
 
     const executor = getExecutor("addReaction")!;
-    await executor(client, baseCtx as never, {
-      type: "addReaction",
-      emoji: "not-an-emoji-at-all",
-    } as never);
+    // A bad emoji is now a thrown failure rather than a warn-and-return, so
+    // processEvent records it as `success: false` instead of logging a
+    // successful execution for an action that never ran.
+    await expect(
+      executor(client, baseCtx as never, {
+        type: "addReaction",
+        emoji: "not-an-emoji-at-all",
+      } as never),
+    ).rejects.toThrow(/not a valid unicode or custom emoji/);
 
     expect(fetchSpy).not.toHaveBeenCalled();
-    expect(warn).toHaveBeenCalledWith(
-      expect.stringContaining("invalid emoji"),
-    );
   });
 
   it("accepts a unicode emoji", async () => {
@@ -102,10 +104,12 @@ describe("addReaction emoji validation", () => {
     const fetchSpy = vi.fn();
     const client = mkClient(fetchSpy);
     const executor = getExecutor("addReaction")!;
-    await executor(client, baseCtx as never, {
-      type: "addReaction",
-      emoji: ":smile:",
-    } as never);
+    await expect(
+      executor(client, baseCtx as never, {
+        type: "addReaction",
+        emoji: ":smile:",
+      } as never),
+    ).rejects.toThrow(/not a valid unicode or custom emoji/);
     expect(fetchSpy).not.toHaveBeenCalled();
   });
 });
diff --git a/apps/bot/tests/features/automation/system/registry-failures.test.ts b/apps/bot/tests/features/automation/system/registry-failures.test.ts
new file mode 100644
index 00000000..2336a10b
--- /dev/null
+++ b/apps/bot/tests/features/automation/system/registry-failures.test.ts
@@ -0,0 +1,174 @@
+import { describe, it, expect, vi } from "vitest";
+
+vi.mock("@fluxcore/config", () => ({
+  config: { token: "t", clientId: "c", guildId: undefined, logLevel: "info" },
+}));
+
+vi.mock("@fluxcore/utils", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("@fluxcore/utils")>();
+  return {
+    ...actual,
+    logger: { warn: vi.fn(), error: vi.fn(), info: vi.fn(), debug: vi.fn() },
+  };
+});
+
+vi.mock("node:dns/promises", () => ({
+  lookup: vi.fn().mockResolvedValue({ address: "1.1.1.1", family: 4 }),
+}));
+
+const { getExecutor } = await import(
+  "../../../../src/features/automation/system/registry.js"
+);
+
+const baseCtx = {
+  eventType: "messageCreated" as const,
+  guildId: "g1",
+  userId: "u1",
+  userName: "alice",
+  userTag: "alice#0001",
+  userMention: "<@u1>",
+  channelId: "c1",
+  guildName: "G",
+  memberCount: 10,
+  timestamp: new Date().toISOString(),
+};
+
+/**
+ * Every executor used to `return` when it could not do its job — no channel
+ * configured, no member to act on, an unresolvable role. processEvent has no
+ * way to tell that apart from success, so it wrote `success: true` to the
+ * ActionLog. A moderator whose auto-role rule never fired saw "214 executions,
+ * 100% success" and had nothing to debug with.
+ *
+ * Every case below must reject, so the caller's existing catch logs it as a
+ * failure with a readable reason.
+ */
+describe("action executors fail loudly rather than silently doing nothing", () => {
+  function clientWithNoChannel() {
+    return { channels: { fetch: vi.fn().mockResolvedValue(null) } } as never;
+  }
+
+  it("sendMessage rejects when no channel is configured", async () => {
+    const run = getExecutor("sendMessage")!;
+    await expect(run(clientWithNoChannel(), baseCtx, { type: "sendMessage", message: "hi" }))
+      .rejects.toThrow(/channelId/i);
+  });
+
+  it("sendMessage rejects when no message is configured", async () => {
+    const run = getExecutor("sendMessage")!;
+    await expect(run(clientWithNoChannel(), baseCtx, { type: "sendMessage", channelId: "c1" }))
+      .rejects.toThrow(/message/i);
+  });
+
+  it("sendMessage rejects when the channel cannot be resolved", async () => {
+    const run = getExecutor("sendMessage")!;
+    await expect(
+      run(clientWithNoChannel(), baseCtx, { type: "sendMessage", channelId: "gone", message: "hi" }),
+    ).rejects.toThrow(/channel/i);
+  });
+
+  it("addRole rejects when no role is configured", async () => {
+    const run = getExecutor("addRole")!;
+    await expect(run({} as never, baseCtx, { type: "addRole" })).rejects.toThrow(/roleId/i);
+  });
+
+  // The canonical reaction-role automation: "react to this message, get a
+  // role". A reaction context carries no member, so this silently did nothing
+  // and reported success for every reaction.
+  it("addRole resolves the member from the guild when the context has none", async () => {
+    const add = vi.fn().mockResolvedValue(undefined);
+    const client = {
+      guilds: {
+        fetch: vi.fn().mockResolvedValue({
+          members: { fetch: vi.fn().mockResolvedValue({ roles: { add, remove: vi.fn() } }) },
+        }),
+      },
+    } as never;
+
+    await getExecutor("addRole")!(client, baseCtx, { type: "addRole", roleId: "r1" });
+
+    expect(add).toHaveBeenCalledWith("r1");
+  });
+
+  it("addRole rejects when the member cannot be resolved", async () => {
+    const client = {
+      guilds: {
+        fetch: vi.fn().mockResolvedValue({
+          members: { fetch: vi.fn().mockRejectedValue(new Error("Unknown Member")) },
+        }),
+      },
+    } as never;
+
+    await expect(
+      getExecutor("addRole")!(client, baseCtx, { type: "addRole", roleId: "r1" }),
+    ).rejects.toThrow(/member/i);
+  });
+
+  it("removeRole resolves the member from the guild when the context has none", async () => {
+    const remove = vi.fn().mockResolvedValue(undefined);
+    const client = {
+      guilds: {
+        fetch: vi.fn().mockResolvedValue({
+          members: { fetch: vi.fn().mockResolvedValue({ roles: { add: vi.fn(), remove } }) },
+        }),
+      },
+    } as never;
+
+    await getExecutor("removeRole")!(client, baseCtx, { type: "removeRole", roleId: "r1" });
+
+    expect(remove).toHaveBeenCalledWith("r1");
+  });
+
+  it("sendDM rejects when the DM cannot be delivered", async () => {
+    const client = {
+      users: { fetch: vi.fn().mockResolvedValue({ send: vi.fn().mockRejectedValue(new Error("Cannot send messages to this user")) }) },
+    } as never;
+
+    await expect(
+      getExecutor("sendDM")!(client, baseCtx, { type: "sendDM", message: "hi" }),
+    ).rejects.toThrow(/cannot send/i);
+  });
+
+  it("setNickname rejects when Discord refuses the change", async () => {
+    const client = {
+      guilds: {
+        fetch: vi.fn().mockResolvedValue({
+          members: {
+            fetch: vi.fn().mockResolvedValue({
+              setNickname: vi.fn().mockRejectedValue(new Error("Missing Permissions")),
+            }),
+          },
+        }),
+      },
+    } as never;
+
+    await expect(
+      getExecutor("setNickname")!(client, baseCtx, { type: "setNickname", nickname: "n" }),
+    ).rejects.toThrow(/missing permissions/i);
+  });
+
+  it("addReaction rejects on an invalid emoji instead of warning and returning", async () => {
+    const client = { channels: { fetch: vi.fn() } } as never;
+
+    await expect(
+      getExecutor("addReaction")!(
+        client,
+        { ...baseCtx, extra: { "message.id": "m1" } },
+        { type: "addReaction", emoji: "not an emoji" },
+      ),
+    ).rejects.toThrow(/emoji/i);
+  });
+
+  it("logToChannel rejects when the channel cannot be resolved", async () => {
+    const run = getExecutor("logToChannel")!;
+    await expect(run(clientWithNoChannel(), baseCtx, { type: "logToChannel", channelId: "gone" }))
+      .rejects.toThrow(/channel/i);
+  });
+
+  it("createThread rejects when the channel cannot be resolved", async () => {
+    const run = getExecutor("createThread")!;
+    await expect(
+      run(clientWithNoChannel(), baseCtx, { type: "createThread", channelId: "gone", threadName: "t" }),
+    ).rejects.toThrow(/channel/i);
+  });
+});
diff --git a/apps/bot/tests/features/automation/system/registry-webhook-safety.test.ts b/apps/bot/tests/features/automation/system/registry-webhook-safety.test.ts
new file mode 100644
index 00000000..ef144c2b
--- /dev/null
+++ b/apps/bot/tests/features/automation/system/registry-webhook-safety.test.ts
@@ -0,0 +1,156 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("@fluxcore/config", () => ({
+  config: { token: "t", clientId: "c", guildId: undefined, logLevel: "info" },
+}));
+
+vi.mock("@fluxcore/utils", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("@fluxcore/utils")>();
+  return {
+    ...actual,
+    logger: { warn: vi.fn(), error: vi.fn(), info: vi.fn(), debug: vi.fn() },
+  };
+});
+
+const lookup = vi.hoisted(() => vi.fn());
+vi.mock("node:dns/promises", () => ({ lookup }));
+
+const { getExecutor } = await import(
+  "../../../../src/features/automation/system/registry.js"
+);
+
+const ctx = {
+  eventType: "memberJoin" as const,
+  guildId: "g1",
+  guildName: "G",
+  userId: "u1",
+  userName: "alice",
+  memberCount: 1,
+  timestamp: new Date().toISOString(),
+};
+
+function cfg(url: string) {
+  return { type: "sendWebhook", webhook: { url } };
+}
+
+/** A Response-alike carrying a body of `size` bytes, streamed in 1 KiB chunks. */
+function streamingResponse(size: number, status = 200) {
+  let sent = 0;
+  return {
+    status,
+    ok: status >= 200 && status < 300,
+    headers: { get: () => null },
+    body: {
+      getReader() {
+        return {
+          async read() {
+            if (sent >= size) return { done: true, value: undefined };
+            const chunk = Math.min(1024, size - sent);
+            sent += chunk;
+            return { done: false, value: new Uint8Array(chunk) };
+          },
+          cancel: vi.fn(),
+          releaseLock() {},
+        };
+      },
+    },
+    text: async () => "x".repeat(size),
+  };
+}
+
+describe("sendWebhook safety", () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+    lookup.mockResolvedValue({ address: "1.1.1.1", family: 4 });
+  });
+
+  it("rejects a missing URL rather than returning silently", async () => {
+    await expect(
+      getExecutor("sendWebhook")!({} as never, ctx, { type: "sendWebhook" }),
+    ).rejects.toThrow(/url/i);
+  });
+
+  it("rejects plain HTTP", async () => {
+    await expect(
+      getExecutor("sendWebhook")!({} as never, ctx, cfg("http://example.com/h")),
+    ).rejects.toThrow(/https/i);
+  });
+
+  it("rejects a private host", async () => {
+    lookup.mockResolvedValue({ address: "10.0.0.5", family: 4 });
+    await expect(
+      getExecutor("sendWebhook")!({} as never, ctx, cfg("https://internal.example/h")),
+    ).rejects.toThrow(/private|internal/i);
+  });
+
+  // The private-IP check ran once, against the ORIGINAL hostname. A public
+  // host answering 302 -> http://169.254.169.254/ walked straight past it into
+  // the cloud metadata service.
+  it("re-validates the target of a redirect", async () => {
+    lookup.mockImplementation(async (host: string) =>
+      host === "evil.example" ? { address: "1.1.1.1", family: 4 } : { address: "169.254.169.254", family: 4 },
+    );
+    vi.stubGlobal(
+      "fetch",
+      vi.fn().mockResolvedValue({
+        status: 302,
+        ok: false,
+        headers: { get: (h: string) => (h.toLowerCase() === "location" ? "https://metadata.internal/latest" : null) },
+        body: null,
+        text: async () => "",
+      }),
+    );
+
+    await expect(
+      getExecutor("sendWebhook")!({} as never, ctx, cfg("https://evil.example/h")),
+    ).rejects.toThrow(/private|internal|redirect/i);
+  });
+
+  it("does not follow redirects endlessly", async () => {
+    const f = vi.fn().mockResolvedValue({
+      status: 302,
+      ok: false,
+      headers: { get: (h: string) => (h.toLowerCase() === "location" ? "https://example.com/loop" : null) },
+      body: null,
+      text: async () => "",
+    });
+    vi.stubGlobal("fetch", f);
+
+    await expect(
+      getExecutor("sendWebhook")!({} as never, ctx, cfg("https://example.com/h")),
+    ).rejects.toThrow(/redirect/i);
+    expect(f.mock.calls.length).toBeLessThanOrEqual(4);
+  });
+
+  it("rejects a non-2xx response so the failure is logged", async () => {
+    vi.stubGlobal("fetch", vi.fn().mockResolvedValue(streamingResponse(10, 500)));
+
+    await expect(
+      getExecutor("sendWebhook")!({} as never, ctx, cfg("https://example.com/h")),
+    ).rejects.toThrow(/500/);
+  });
+
+  it("stops reading a response body that exceeds the cap", async () => {
+    const reader = { calls: 0 };
+    const oversize = streamingResponse(5_000_000);
+    const originalGetReader = oversize.body!.getReader.bind(oversize.body);
+    oversize.body!.getReader = () => {
+      reader.calls++;
+      return originalGetReader();
+    };
+    vi.stubGlobal("fetch", vi.fn().mockResolvedValue(oversize));
+
+    // Must complete rather than buffering 5 MB into memory.
+    await getExecutor("sendWebhook")!({} as never, ctx, cfg("https://example.com/h"));
+    expect(reader.calls).toBe(1);
+  });
+
+  it("sends successfully on a 2xx", async () => {
+    const f = vi.fn().mockResolvedValue(streamingResponse(10));
+    vi.stubGlobal("fetch", f);
+
+    await getExecutor("sendWebhook")!({} as never, ctx, cfg("https://example.com/h"));
+
+    expect(f).toHaveBeenCalledOnce();
+  });
+});
diff --git a/apps/bot/tests/shared/client/ExtendedClient.test.ts b/apps/bot/tests/shared/client/ExtendedClient.test.ts
index 0e660021..9b17e097 100644
--- a/apps/bot/tests/shared/client/ExtendedClient.test.ts
+++ b/apps/bot/tests/shared/client/ExtendedClient.test.ts
@@ -11,7 +11,7 @@ vi.mock("@fluxcore/config", () => ({
 }));
 
 import { ExtendedClient } from "../../../src/shared/client/ExtendedClient.js";
-import { Collection } from "discord.js";
+import { Collection, Partials } from "discord.js";
 
 describe("ExtendedClient", () => {
   it("instantiates without errors", () => {
@@ -26,4 +26,21 @@ describe("ExtendedClient", () => {
     expect(client.commands.size).toBe(0);
     client.destroy();
   });
+
+  // Without partials, discord.js drops any gateway event whose primary
+  // structure is not already cached. The bot only caches messages seen since
+  // its last restart, so reactionAdded / reactionRemoved / messageDeleted
+  // never reached a handler for an older message — which silently breaks
+  // every reaction-role automation attached to a pinned rules message.
+  it("enables the partials the reaction and message-delete triggers need", () => {
+    const client = new ExtendedClient();
+
+    const partials = client.options.partials ?? [];
+    expect(partials).toContain(Partials.Message);
+    expect(partials).toContain(Partials.Reaction);
+    expect(partials).toContain(Partials.Channel);
+    expect(partials).toContain(Partials.User);
+
+    client.destroy();
+  });
 });
\ No newline at end of file
diff --git a/apps/dashboard/src/client/features/automation/components/ActionFields.tsx b/apps/dashboard/src/client/features/automation/components/ActionFields.tsx
index d9e13088..ee51a686 100644
--- a/apps/dashboard/src/client/features/automation/components/ActionFields.tsx
+++ b/apps/dashboard/src/client/features/automation/components/ActionFields.tsx
@@ -1,3 +1,4 @@
+import { useState } from "react";
 import { useTranslation } from "react-i18next";
 import { Icon } from "../../../shared/components/Icon";
 import { SearchableSelect } from "../../../shared/ui/searchable-select";
@@ -15,6 +16,8 @@ import {
 import { VariableEditor } from "../../../shared/ui/variable-field";
 import type { VariableDescriptor } from "../../../shared/ui/variable-field";
 import type { ActionFieldDescriptor, Channel, Role } from "../../../shared/lib/schemas";
+import { channelIconName, isMessageableChannel } from "../../../shared/lib/channelTypes";
+import { useAutomationLabels } from "../lib/labels";
 
 const VARIABLE_FIELD_KEYS = new Set([
   "message",
@@ -33,6 +36,14 @@ interface ActionFieldsProps {
   channels: Channel[];
   roles: Role[];
   variables: VariableDescriptor[];
+  /** The action type these fields belong to, so labels can be translated. */
+  actionType?: string;
+  /**
+   * Mark empty required fields invalid with a linked message. A red asterisk
+   * was the only signal, so a screen-reader user got no feedback at all about
+   * why Save was disabled.
+   */
+  showErrors?: boolean;
 }
 
 function getNestedValue(obj: Record<string, unknown>, path: string): unknown {
@@ -45,6 +56,86 @@ function getNestedValue(obj: Record<string, unknown>, path: string): unknown {
   return current;
 }
 
+/**
+ * A textarea backed by a JSON value.
+ *
+ * The raw text lives in local state so a half-typed object does not have to be
+ * valid to be typeable; only a successful parse is committed upward. The model
+ * types `webhook.headers` as Record<string,string>, and writing the raw string
+ * there made the rule permanently unsavable ("Expected object, received
+ * string" — English-only, naming no field).
+ */
+function JsonField({
+  id,
+  value,
+  onChange,
+  placeholder,
+  maxLength,
+  invalidLabel,
+}: {
+  id: string;
+  value: unknown;
+  onChange: (value: unknown) => void;
+  placeholder?: string;
+  maxLength?: number;
+  invalidLabel: string;
+}) {
+  const serialised =
+    value === undefined || value === null || value === ""
+      ? ""
+      : typeof value === "string"
+        ? value
+        : JSON.stringify(value, null, 2);
+  const [text, setText] = useState(serialised);
+  const [error, setError] = useState(false);
+  const errorId = `${id}-json-error`;
+
+  const handle = (next: string) => {
+    setText(next);
+    if (next.trim() === "") {
+      setError(false);
+      onChange(undefined);
+      return;
+    }
+    try {
+      const parsed: unknown = JSON.parse(next);
+      const isStringRecord =
+        typeof parsed === "object" &&
+        parsed !== null &&
+        !Array.isArray(parsed) &&
+        Object.values(parsed as Record<string, unknown>).every((v) => typeof v === "string");
+      if (!isStringRecord) {
+        setError(true);
+        return;
+      }
+      setError(false);
+      onChange(parsed);
+    } catch {
+      setError(true);
+    }
+  };
+
+  return (
+    <>
+      <Textarea
+        id={id}
+        value={text}
+        onChange={(e) => handle(e.target.value)}
+        placeholder={placeholder}
+        maxLength={maxLength}
+        aria-invalid={error || undefined}
+        aria-describedby={error ? errorId : undefined}
+        className="font-mono text-xs"
+      />
+      {error && (
+        <p id={errorId} role="alert" className="mt-1 text-xs text-danger">
+          {invalidLabel}
+        </p>
+      )}
+    </>
+  );
+}
+
 export function ActionFields({
   fields,
   values,
@@ -52,13 +143,29 @@ export function ActionFields({
   channels,
   roles,
   variables,
+  showErrors,
+  actionType,
 }: ActionFieldsProps) {
   const { t } = useTranslation("common");
+  const labels = useAutomationLabels(undefined);
   return (
     <div className="flex flex-col gap-3">
       {fields.map((field) => {
         const value = getNestedValue(values, field.key) ?? "";
+        // ACTION_TYPE_FIELDS is hardcoded English (the bot needs it too), so
+        // the label and placeholder are translated on the way out.
+        const fieldLabel = actionType
+          ? labels.fieldLabel(actionType, field.key, field.label)
+          : field.label;
+        const fieldPlaceholder = actionType
+          ? labels.fieldPlaceholder(actionType, field.key, field.placeholder)
+          : field.placeholder;
         const fieldId = `af-${field.key.replace(/\./g, "-")}`;
+        const missing = !!showErrors && !!field.required && (value === "" || value === undefined || value === null);
+        const errorId = `${fieldId}-error`;
+        const invalidProps = missing
+          ? { "aria-invalid": true as const, "aria-describedby": errorId }
+          : {};
         const colorHex =
           typeof value === "number"
             ? `#${value.toString(16).padStart(6, "0")}`
@@ -67,7 +174,7 @@ export function ActionFields({
         return (
           <div key={field.key}>
             <Label htmlFor={fieldId}>
-              {field.label}
+              {fieldLabel}
               {field.required && (
                 <>
                   <span aria-hidden="true" className="text-danger"> *</span>
@@ -86,13 +193,13 @@ export function ActionFields({
                 searchPlaceholder={t("form.search")}
                 noResultsLabel={t("form.noResults")}
                 options={channels
-                  .filter((c) => c.type === 0 || c.type === 2)
+                  .filter((c) => isMessageableChannel(c.type))
                   .map((c) => ({
                     value: c.id,
                     label: c.name,
                     icon: (
                       <Icon
-                        name={c.type === 2 ? "volume_up" : "hash"}
+                        name={channelIconName(c.type)}
                         size={14}
                         className="text-text-muted"
                       />
@@ -123,7 +230,7 @@ export function ActionFields({
                   variables={variables}
                   multiline={false}
                   aria-required={field.required}
-                  placeholder={field.placeholder}
+                  placeholder={fieldPlaceholder}
                   maxLength={field.maxLength}
                 />
               ) : (
@@ -131,9 +238,10 @@ export function ActionFields({
                   id={fieldId}
                   type="text"
                   aria-required={field.required}
+                  {...invalidProps}
                   value={String(value)}
                   onChange={(e) => onChange(field.key, e.target.value)}
-                  placeholder={field.placeholder}
+                  placeholder={fieldPlaceholder}
                   maxLength={field.maxLength}
                 />
               )
@@ -148,16 +256,17 @@ export function ActionFields({
                   variables={variables}
                   multiline={true}
                   aria-required={field.required}
-                  placeholder={field.placeholder}
+                  placeholder={fieldPlaceholder}
                   maxLength={field.maxLength}
                 />
               ) : (
                 <Textarea
                   id={fieldId}
                   aria-required={field.required}
+                  {...invalidProps}
                   value={String(value)}
                   onChange={(e) => onChange(field.key, e.target.value)}
-                  placeholder={field.placeholder}
+                  placeholder={fieldPlaceholder}
                   maxLength={field.maxLength}
                 />
               )
@@ -166,7 +275,7 @@ export function ActionFields({
             {field.type === "color" && (
               <ColorPicker
                 id={fieldId}
-                aria-label={field.label}
+                aria-label={fieldLabel}
                 value={colorHex}
                 onChange={(hex) => {
                   const normalized = hex.startsWith("#") ? hex.slice(1) : hex;
@@ -176,6 +285,17 @@ export function ActionFields({
               />
             )}
 
+            {field.type === "json" && (
+              <JsonField
+                id={fieldId}
+                value={getNestedValue(values, field.key)}
+                onChange={(v) => onChange(field.key, v)}
+                placeholder={fieldPlaceholder}
+                maxLength={field.maxLength}
+                invalidLabel={t("form.invalidJson")}
+              />
+            )}
+
             {field.type === "select" && field.options && (
               <Select
                 value={String(value) || undefined}
@@ -193,6 +313,11 @@ export function ActionFields({
                 </SelectContent>
               </Select>
             )}
+            {missing && (
+              <p id={errorId} role="alert" className="mt-1 text-xs text-danger">
+                {t("form.fieldRequired", { field: fieldLabel })}
+              </p>
+            )}
           </div>
         );
       })}
diff --git a/apps/dashboard/src/client/features/automation/components/ConditionsEditor.tsx b/apps/dashboard/src/client/features/automation/components/ConditionsEditor.tsx
index a8c0652b..39f896f4 100644
--- a/apps/dashboard/src/client/features/automation/components/ConditionsEditor.tsx
+++ b/apps/dashboard/src/client/features/automation/components/ConditionsEditor.tsx
@@ -1,13 +1,24 @@
-import { useState, useId } from "react";
+import { useState } from "react";
 import { useTranslation } from "react-i18next";
 import { Icon } from "../../../shared/components/Icon";
 import { Badge } from "../../../shared/ui/badge";
 import { Button } from "../../../shared/ui/button";
-import { Input } from "../../../shared/ui/input";
-import { Label } from "../../../shared/ui/label";
 import { DiscordMultiSelect } from "../../../shared/ui/discord-multi-select";
+import { MemberMultiSelect } from "../../../shared/ui/member-multi-select";
 import type { ActionConditions } from "../../../shared/lib/schemas";
 
+/** The three data a trigger filter can key on. Mirrors ConditionSubject. */
+export type ConditionSubject = "channel" | "role" | "user";
+
+/** Which condition keys belong to which subject. */
+const SUBJECT_KEYS: Record<ConditionSubject, (keyof ActionConditions)[]> = {
+  channel: ["channelIds", "excludeChannelIds"],
+  role: ["roleIds", "excludeRoleIds"],
+  user: ["userIds", "excludeUserIds"],
+};
+
+const ALL_SUBJECTS: ConditionSubject[] = ["channel", "role", "user"];
+
 interface ConditionsEditorProps {
   guildId: string;
   conditions: ActionConditions;
@@ -15,117 +26,16 @@ interface ConditionsEditorProps {
   compact?: boolean;
   /** Always show expanded, no collapse button */
   alwaysExpanded?: boolean;
-}
-
-function ChipList({
-  items,
-  onRemove,
-  color = "secondary",
-}: {
-  items: { id: string; label: string }[];
-  onRemove: (id: string) => void;
-  color?: "secondary" | "destructive";
-}) {
-  const { t } = useTranslation("rules");
-  if (items.length === 0) return null;
-  return (
-    <div className="flex flex-wrap gap-1.5">
-      {items.map((item) => (
-        <Badge
-          key={item.id}
-          variant={color}
-          className="gap-1 pe-1 text-[11px]"
-        >
-          {item.label}
-          <button
-            type="button"
-            aria-label={t("conditions.removeItem", { label: item.label })}
-            onClick={() => onRemove(item.id)}
-            className="ms-0.5 rounded-full p-1 hover:bg-white/10 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
-          >
-            <Icon name="close" size={10} />
-          </button>
-        </Badge>
-      ))}
-    </div>
-  );
-}
-
-function UserIdInput({
-  label,
-  selectedIds,
-  onAdd,
-  onRemove,
-  chipColor = "secondary",
-}: {
-  label: string;
-  selectedIds: string[];
-  onAdd: (id: string) => void;
-  onRemove: (id: string) => void;
-  chipColor?: "secondary" | "destructive";
-}) {
-  const { t } = useTranslation(["rules", "common"]);
-  const [input, setInput] = useState("");
-  const [touched, setTouched] = useState(false);
-  const fieldId = useId();
-  const errorId = `${fieldId}-error`;
-  const trimmed = input.trim();
-  const isValid = /^\d{17,20}$/.test(trimmed);
-  const showError = touched && trimmed.length > 0 && !isValid;
-
-  const handleAdd = () => {
-    if (isValid && !selectedIds.includes(trimmed)) {
-      onAdd(trimmed);
-      setInput("");
-      setTouched(false);
-    } else {
-      setTouched(true);
-    }
-  };
-
-  return (
-    <div className="space-y-1.5">
-      <Label htmlFor={fieldId} className="text-xs">{label}</Label>
-      <div className="flex gap-1.5">
-        <Input
-          id={fieldId}
-          type="text"
-          inputMode="numeric"
-          value={input}
-          aria-invalid={showError || undefined}
-          aria-describedby={showError ? errorId : undefined}
-          onChange={(e) => setInput(e.target.value)}
-          onBlur={() => setTouched(true)}
-          onKeyDown={(e) =>
-            e.key === "Enter" && (e.preventDefault(), handleAdd())
-          }
-          placeholder={t("conditions.userId")}
-          className="h-8 flex-1 text-xs"
-        />
-        <Button
-          type="button"
-          variant="ghost"
-          size="sm"
-          aria-label={t("conditions.addUserId")}
-          className="h-8 px-2"
-          onClick={handleAdd}
-          disabled={!trimmed || !isValid}
-        >
-          <Icon name="add" size={14} />
-        </Button>
-      </div>
-      {showError && (
-        <p id={errorId} role="alert" className="text-xs text-danger">
-          {t("conditions.userIdInvalid")}
-        </p>
-      )}
-      <ChipList
-        items={selectedIds.map((id) => ({ id, label: id }))}
-        onRemove={onRemove}
-        color={chipColor}
-      />
-    </div>
-  );
+  /**
+   * Which filter subjects the selected trigger can actually evaluate, from
+   * EVENT_CONDITION_SUPPORT. Filters fail closed in the bot, so offering one
+   * the event context can never answer would silently stop the rule from
+   * firing rather than simply doing nothing.
+   *
+   * Undefined means no trigger is chosen yet — offer everything rather than
+   * an empty panel, since the user is about to pick one.
+   */
+  supported?: ConditionSubject[];
 }
 
 export function ConditionsEditor({
@@ -134,12 +44,33 @@ export function ConditionsEditor({
   onChange,
   compact,
   alwaysExpanded,
+  supported,
 }: ConditionsEditorProps) {
   const { t } = useTranslation("rules");
   const update = (patch: Partial<ActionConditions>) => {
     onChange({ ...conditions, ...patch });
   };
 
+  const subjects = supported ?? ALL_SUBJECTS;
+  const shows = (subject: ConditionSubject) => subjects.includes(subject);
+
+  // A rule can carry filters from before its trigger was changed. The runtime
+  // now refuses to fire such a rule, so the editor has to surface them rather
+  // than just hiding the controls that would reveal them.
+  const strandedSubjects = ALL_SUBJECTS.filter(
+    (subject) =>
+      !shows(subject) &&
+      SUBJECT_KEYS[subject].some((key) => (conditions[key]?.length ?? 0) > 0),
+  );
+
+  const clearStranded = () => {
+    const next = { ...conditions };
+    for (const subject of strandedSubjects) {
+      for (const key of SUBJECT_KEYS[subject]) delete next[key];
+    }
+    onChange(next);
+  };
+
   const hasAnyConditions =
     (conditions.channelIds?.length ?? 0) +
       (conditions.roleIds?.length ?? 0) +
@@ -204,38 +135,65 @@ export function ConditionsEditor({
         {t("conditions.description")}
       </p>
 
+      {strandedSubjects.length > 0 && (
+        <div
+          role="alert"
+          className="space-y-2 rounded-md border border-warning/30 bg-warning/5 p-3"
+        >
+          <p className="flex items-start gap-1.5 text-[11px] leading-relaxed text-text-secondary">
+            <Icon name="warning" size={14} className="mt-px shrink-0 text-warning" />
+            {t("conditions.unsupportedWarning", {
+              filters: strandedSubjects
+                .map((s) => t(`conditions.${s === "channel" ? "channels" : s === "role" ? "roles" : "users"}`))
+                .join(", "),
+            })}
+          </p>
+          <Button
+            type="button"
+            variant="ghost"
+            size="sm"
+            className="w-full text-xs"
+            onClick={clearStranded}
+          >
+            {t("conditions.removeUnsupported")}
+          </Button>
+        </div>
+      )}
+
       {/* Include filters */}
       <div className="space-y-3">
         <span className="section-label text-secondary">
           {t("conditions.include")}
         </span>
-        <DiscordMultiSelect
-          guildId={guildId}
-          type="any"
-          selectedIds={conditions.channelIds ?? []}
-          onChange={(ids) => update({ channelIds: ids })}
-          placeholder={t("conditions.addChannel")}
-          label={t("conditions.channels")}
-        />
-        <DiscordMultiSelect
-          guildId={guildId}
-          type="role"
-          selectedIds={conditions.roleIds ?? []}
-          onChange={(ids) => update({ roleIds: ids })}
-          placeholder={t("conditions.addRole")}
-          label={t("conditions.roles")}
-        />
-        <UserIdInput
-          label={t("conditions.users")}
-          selectedIds={conditions.userIds ?? []}
-          onAdd={(id) => {
-            const current = conditions.userIds ?? [];
-            if (!current.includes(id)) update({ userIds: [...current, id] });
-          }}
-          onRemove={(id) =>
-            update({ userIds: (conditions.userIds ?? []).filter((v) => v !== id) })
-          }
-        />
+        {shows("channel") && (
+          <DiscordMultiSelect
+            guildId={guildId}
+            type="any"
+            selectedIds={conditions.channelIds ?? []}
+            onChange={(ids) => update({ channelIds: ids })}
+            placeholder={t("conditions.addChannel")}
+            label={t("conditions.includeChannels")}
+          />
+        )}
+        {shows("role") && (
+          <DiscordMultiSelect
+            guildId={guildId}
+            type="role"
+            selectedIds={conditions.roleIds ?? []}
+            onChange={(ids) => update({ roleIds: ids })}
+            placeholder={t("conditions.addRole")}
+            label={t("conditions.includeRoles")}
+          />
+        )}
+        {shows("user") && (
+          <MemberMultiSelect
+            guildId={guildId}
+            label={t("conditions.includeUsers")}
+            placeholder={t("conditions.addMember")}
+            selectedIds={conditions.userIds ?? []}
+            onChange={(ids) => update({ userIds: ids })}
+          />
+        )}
       </div>
 
       {/* Exclude filters */}
@@ -243,39 +201,36 @@ export function ConditionsEditor({
         <span className="section-label text-danger">
           {t("conditions.exclude")}
         </span>
-        <DiscordMultiSelect
-          guildId={guildId}
-          type="any"
-          selectedIds={conditions.excludeChannelIds ?? []}
-          onChange={(ids) => update({ excludeChannelIds: ids })}
-          placeholder={t("conditions.excludeChannel")}
-          label={t("conditions.channels")}
-        />
-        <DiscordMultiSelect
-          guildId={guildId}
-          type="role"
-          selectedIds={conditions.excludeRoleIds ?? []}
-          onChange={(ids) => update({ excludeRoleIds: ids })}
-          placeholder={t("conditions.excludeRole")}
-          label={t("conditions.roles")}
-        />
-        <UserIdInput
-          label={t("conditions.users")}
-          selectedIds={conditions.excludeUserIds ?? []}
-          onAdd={(id) => {
-            const current = conditions.excludeUserIds ?? [];
-            if (!current.includes(id))
-              update({ excludeUserIds: [...current, id] });
-          }}
-          onRemove={(id) =>
-            update({
-              excludeUserIds: (conditions.excludeUserIds ?? []).filter(
-                (v) => v !== id,
-              ),
-            })
-          }
-          chipColor="destructive"
-        />
+        {shows("channel") && (
+          <DiscordMultiSelect
+            guildId={guildId}
+            type="any"
+            selectedIds={conditions.excludeChannelIds ?? []}
+            onChange={(ids) => update({ excludeChannelIds: ids })}
+            placeholder={t("conditions.excludeChannel")}
+            label={t("conditions.excludeChannels")}
+          />
+        )}
+        {shows("role") && (
+          <DiscordMultiSelect
+            guildId={guildId}
+            type="role"
+            selectedIds={conditions.excludeRoleIds ?? []}
+            onChange={(ids) => update({ excludeRoleIds: ids })}
+            placeholder={t("conditions.excludeRole")}
+            label={t("conditions.excludeRoles")}
+          />
+        )}
+        {shows("user") && (
+          <MemberMultiSelect
+            guildId={guildId}
+            label={t("conditions.excludeUsers")}
+            placeholder={t("conditions.addMember")}
+            selectedIds={conditions.excludeUserIds ?? []}
+            onChange={(ids) => update({ excludeUserIds: ids })}
+            chipColor="destructive"
+          />
+        )}
       </div>
 
       {hasAnyConditions && (
diff --git a/apps/dashboard/src/client/features/automation/components/RuleList.tsx b/apps/dashboard/src/client/features/automation/components/RuleList.tsx
index d0ccd4d6..3e276687 100644
--- a/apps/dashboard/src/client/features/automation/components/RuleList.tsx
+++ b/apps/dashboard/src/client/features/automation/components/RuleList.tsx
@@ -20,6 +20,7 @@ import {
   TooltipProvider,
 } from "../../../shared/ui/tooltip";
 import { ACTION_ICONS, EVENT_ICONS, getActionPreview } from "../lib/rule-icons";
+import { useAutomationLabels } from "../lib/labels";
 import type { ActionRule, Constants } from "../../../shared/lib/schemas";
 
 interface RuleListProps {
@@ -59,6 +60,7 @@ export function RuleList({
   onSelectionChange,
 }: RuleListProps) {
   const { t } = useTranslation(["rules", "common"]);
+  const labels = useAutomationLabels(constants);
   const selectable = !!selectedIds && !!onSelectionChange;
 
   const toggleSelection = (ruleId: number) => {
@@ -72,16 +74,47 @@ export function RuleList({
     onSelectionChange(next);
   };
 
+  /**
+   * A saved rule can be dead: an action missing a required field never
+   * executes, and the list showed it as perfectly healthy. Older rules
+   * predate the save-time guard, and the `/actions` command and the API can
+   * still produce them.
+   */
+  const isMisconfigured = (rule: ActionRule): boolean => {
+    if (!constants) return false;
+    const effective = rule.steps?.length
+      ? rule.steps.filter((s) => s.type === "action").map((s) => s.action)
+      : rule.actions;
+    if (effective.length === 0) return true;
+    return effective.some((action) => {
+      if (!action.type) return true;
+      return (constants.actionTypeFields?.[action.type] ?? []).some((field) => {
+        if (!field.required) return false;
+        const value = field.key
+          .split(".")
+          .reduce<unknown>(
+            (acc, part) =>
+              acc && typeof acc === "object"
+                ? (acc as Record<string, unknown>)[part]
+                : undefined,
+            action as unknown as Record<string, unknown>,
+          );
+        return value === undefined || value === null || value === "";
+      });
+    });
+  };
+
   return (
     <TooltipProvider>
       <div className="flex flex-col gap-3">
         {rules.map((rule) => {
           const eventLabel =
-            constants?.eventTypes[rule.eventType]?.label ?? rule.eventType;
+            labels.eventLabel(rule.eventType);
           const eventIcon = EVENT_ICONS[rule.eventType] ?? "bolt";
           const isSelected = selectedIds?.has(rule.id) ?? false;
           const hasSteps = !!(rule.steps?.length && rule.entryStepId);
           const lastFired = formatLastFired(rule.lastFired, t);
+          const misconfigured = isMisconfigured(rule);
 
           return (
             <div
@@ -145,6 +178,22 @@ export function RuleList({
                           {t("ruleList.disabledBadge")}
                         </Badge>
                       )}
+                      {misconfigured && (
+                        <Tooltip>
+                          <TooltipTrigger asChild>
+                            <Badge
+                              variant="outline"
+                              className="gap-0.5 border-warning/50 px-1.5 py-0 text-[11px] text-warning"
+                            >
+                              <Icon name="warning" size={10} />
+                              {t("ruleList.misconfiguredBadge")}
+                            </Badge>
+                          </TooltipTrigger>
+                          <TooltipContent>
+                            {t("ruleList.misconfiguredHint")}
+                          </TooltipContent>
+                        </Tooltip>
+                      )}
                       {hasSteps && (
                         <Tooltip>
                           <TooltipTrigger asChild>
@@ -263,7 +312,7 @@ export function RuleList({
                   {/* Action chips */}
                   {rule.actions.map((action, i) => {
                     const actionLabel =
-                      constants?.actionTypes[action.type]?.label ?? action.type;
+                      labels.actionLabel(action.type);
                     const actionIcon = ACTION_ICONS[action.type] ?? "play_arrow";
                     const preview = getActionPreview(action, t);
                     const isConfigured = action.type !== "";
diff --git a/apps/dashboard/src/client/features/automation/lib/labels.ts b/apps/dashboard/src/client/features/automation/lib/labels.ts
new file mode 100644
index 00000000..2526ac59
--- /dev/null
+++ b/apps/dashboard/src/client/features/automation/lib/labels.ts
@@ -0,0 +1,95 @@
+import { useTranslation } from "react-i18next";
+import type { Constants } from "../../../shared/lib/schemas";
+
+/**
+ * Resolves the automation vocabulary — trigger names, action names, their
+ * descriptions, and action field labels/placeholders — through i18n.
+ *
+ * These all live as hardcoded English in
+ * `packages/systems/src/actions/constants.ts` and are served raw by
+ * /api/actions/constants, because the bot needs them too (embed titles,
+ * `/actions` autocomplete). That made the entire automation builder
+ * English-only in an app with 48 locales: every trigger in the picker, every
+ * action chip in the rule list, every field label in the editor.
+ *
+ * Rather than move the data (the bot still needs it), the client translates it
+ * on the way out, falling back to the API's English when a key is missing —
+ * so an untranslated locale degrades to today's behaviour instead of blanks.
+ */
+/** The translator shape these helpers need — structural, so tests need no cast. */
+export type TranslateFn = (
+  key: string,
+  params?: Record<string, unknown>,
+) => string;
+
+export interface AutomationLabels {
+  eventLabel: (eventType: string) => string;
+  eventDescription: (eventType: string) => string;
+  actionLabel: (actionType: string) => string;
+  actionDescription: (actionType: string) => string;
+  fieldLabel: (actionType: string, fieldKey: string, fallback: string) => string;
+  fieldPlaceholder: (
+    actionType: string,
+    fieldKey: string,
+    fallback: string | undefined,
+  ) => string | undefined;
+}
+
+/**
+ * Pure form, for `useWorkflowNodes` and anywhere else that already has a `t`
+ * rather than being able to call a hook.
+ */
+export function makeAutomationLabels(
+  t: TranslateFn,
+  constants: Constants | undefined,
+): AutomationLabels {
+  const withFallback = (key: string, fallback: string): string => {
+    const translated = t(key, { defaultValue: "" });
+    return translated || fallback;
+  };
+
+  return {
+    eventLabel: (eventType: string): string =>
+      withFallback(
+        `eventTypes.${eventType}.label`,
+        constants?.eventTypes[eventType]?.label ?? eventType,
+      ),
+    eventDescription: (eventType: string): string =>
+      withFallback(
+        `eventTypes.${eventType}.description`,
+        constants?.eventTypes[eventType]?.description ?? "",
+      ),
+    actionLabel: (actionType: string): string =>
+      withFallback(
+        `actionTypes.${actionType}.label`,
+        constants?.actionTypes[actionType]?.label ?? actionType,
+      ),
+    actionDescription: (actionType: string): string =>
+      withFallback(
+        `actionTypes.${actionType}.description`,
+        constants?.actionTypes[actionType]?.description ?? "",
+      ),
+    /** Field keys contain dots, which i18next reads as nesting — escape them. */
+    fieldLabel: (actionType: string, fieldKey: string, fallback: string): string =>
+      withFallback(`actionFields.${actionType}_${fieldKey.replace(/\./g, "_")}.label`, fallback),
+    fieldPlaceholder: (
+      actionType: string,
+      fieldKey: string,
+      fallback: string | undefined,
+    ): string | undefined =>
+      fallback === undefined
+        ? undefined
+        : withFallback(
+            `actionFields.${actionType}_${fieldKey.replace(/\./g, "_")}.placeholder`,
+            fallback,
+          ),
+  };
+}
+
+/** Hook form, for components. */
+export function useAutomationLabels(
+  constants: Constants | undefined,
+): AutomationLabels {
+  const { t } = useTranslation("rules");
+  return makeAutomationLabels(t, constants);
+}
diff --git a/apps/dashboard/src/client/features/automation/lib/workflow-validation.ts b/apps/dashboard/src/client/features/automation/lib/workflow-validation.ts
index 5d104088..0b4e9417 100644
--- a/apps/dashboard/src/client/features/automation/lib/workflow-validation.ts
+++ b/apps/dashboard/src/client/features/automation/lib/workflow-validation.ts
@@ -209,9 +209,15 @@ function validateAction(
 
     const value = getNestedValue(action, field.key);
     if (value === undefined || value === null || value === "") {
+      // An action missing a required field cannot execute — the bot has no
+      // channel to post to, no role to add. Saving it produces a rule that
+      // looks healthy in the list and silently never fires, so this is an
+      // error (blocks Save), not advice. Genuinely advisory graph issues
+      // (empty condition value, unconnected delay, unreachable step) stay
+      // warnings so the error/warning split keeps meaning something.
       issues.push({
         nodeId,
-        level: "warning",
+        level: "error",
         message: t("validation.fieldRequired", { label, field: field.label }),
       });
     }
diff --git a/apps/dashboard/src/client/features/automation/workflow/NodeDetailPanel.tsx b/apps/dashboard/src/client/features/automation/workflow/NodeDetailPanel.tsx
index 8aa2934b..d03628be 100644
--- a/apps/dashboard/src/client/features/automation/workflow/NodeDetailPanel.tsx
+++ b/apps/dashboard/src/client/features/automation/workflow/NodeDetailPanel.tsx
@@ -5,6 +5,7 @@ import { useChannels } from "../../../shared/hooks/useChannels";
 import { useRoles } from "../../../shared/hooks/useRoles";
 import { ActionFields } from "../components/ActionFields";
 import { buildAutomationVariables, DiscordMessagePreview, usePreviewContext } from "../../../shared/ui/variable-field";
+import type { VariableDescriptor } from "../../../shared/ui/variable-field";
 import { Button } from "../../../shared/ui/button";
 import { Label } from "../../../shared/ui/label";
 import { Input } from "../../../shared/ui/input";
@@ -15,6 +16,7 @@ import { Tabs, TabsList, TabsTrigger, TabsContent } from "../../../shared/ui/tab
 import { SearchableSelect } from "../../../shared/ui/searchable-select";
 import { EVENT_ICONS } from "../lib/rule-icons";
 import { buildActionTypeOptions } from "../lib/action-options";
+import { useAutomationLabels, makeAutomationLabels, type TranslateFn } from "../lib/labels";
 import { ConditionsEditor } from "../components/ConditionsEditor";
 import { ConfirmDialog } from "../../../shared/components/ConfirmDialog";
 import type {
@@ -66,6 +68,41 @@ interface StepPanelProps {
 
 type NodeDetailPanelProps = TriggerPanelProps | ActionPanelProps | StepPanelProps;
 
+/**
+ * Builds the config for a newly chosen action type, carrying over any value
+ * whose key the new type also declares.
+ *
+ * Resetting to `{ type }` erased everything the user had typed the instant the
+ * dropdown closed — with no warning, no undo, and the draft autosave
+ * immediately persisting the emptied action. sendMessage -> sendDM is the
+ * common case: both have a `message`, and a long composed message vanished.
+ */
+export function carryOverActionFields(
+  previous: Record<string, unknown>,
+  newType: string,
+  actionTypeFields: Record<string, { key: string }[]>,
+): Record<string, unknown> {
+  const next: Record<string, unknown> = { type: newType };
+  for (const field of actionTypeFields[newType] ?? []) {
+    const value = getNestedValue(previous, field.key);
+    if (value !== undefined && value !== null && value !== "") {
+      Object.assign(next, setNestedValue(next, field.key, value));
+    }
+  }
+  return next;
+}
+
+function getNestedValue(obj: Record<string, unknown>, path: string): unknown {
+  let current: unknown = obj;
+  for (const part of path.split(".")) {
+    if (current === null || current === undefined || typeof current !== "object") {
+      return undefined;
+    }
+    current = (current as Record<string, unknown>)[part];
+  }
+  return current;
+}
+
 function setNestedValue(
   obj: Record<string, unknown>,
   path: string,
@@ -207,6 +244,7 @@ function TriggerPanel({
   onConditionsChange,
 }: TriggerPanelProps) {
   const { t } = useTranslation(["rules", "common"]);
+  const labels = useAutomationLabels(constants);
   const variables = eventType ? (constants.eventTypeVariables[eventType] ?? []) : [];
 
   const eventOptions = useMemo(
@@ -274,7 +312,7 @@ function TriggerPanel({
           {eventType && constants.eventTypes[eventType] && (
             <div className="rounded-lg bg-surface-lowest p-3">
               <p className="text-xs leading-relaxed text-text-muted">
-                {constants.eventTypes[eventType].description}
+                {labels.eventDescription(eventType)}
               </p>
             </div>
           )}
@@ -286,6 +324,9 @@ function TriggerPanel({
           conditions={conditions}
           onChange={onConditionsChange}
           guildId={guildId}
+          // Undefined until a trigger is picked — ConditionsEditor then offers
+          // everything rather than rendering an empty panel.
+          supported={eventType ? constants.eventConditionSupport[eventType] : undefined}
           alwaysExpanded
         />
       </TabsContent>
@@ -297,39 +338,110 @@ function TriggerPanel({
   );
 }
 
-function ActionPanel({
-  index,
+/**
+ * The action type picker, its fields and its message preview.
+ *
+ * Shared by the linear ActionPanel and the step-mode StepPanel so the two can
+ * never diverge again — step mode previously rendered a stripped-down copy with
+ * no preview, so adding a single condition or delay to a rule silently removed
+ * the preview from every action in it.
+ */
+function ActionSettings({
   action,
   constants,
   guildId,
-  eventType,
-  totalActions,
-  onActionChange,
-  onActionRemove,
-  onActionMove,
-  canRemove,
-}: ActionPanelProps) {
+  variables,
+  onTypeChange,
+  onFieldChange,
+}: {
+  action: ActionConfig;
+  constants: Constants;
+  guildId: string;
+  variables: VariableDescriptor[];
+  onTypeChange: (type: string) => void;
+  onFieldChange: (key: string, value: unknown) => void;
+}) {
   const { t } = useTranslation(["rules", "common"]);
   const { data: channels = [] } = useChannels(guildId);
   const { data: roles = [] } = useRoles(guildId);
+  const real = usePreviewContext(guildId);
+  const actionTypeId = useId();
   const fields: ActionFieldDescriptor[] =
     constants.actionTypeFields[action.type] ?? [];
-  const variables = buildAutomationVariables(constants, eventType);
-  const real = usePreviewContext(guildId);
 
-  const handleTypeChange = (newType: string) => {
-    onActionChange(index, { type: newType });
-  };
+  return (
+    <>
+      <div>
+        <Label htmlFor={actionTypeId}>
+          {t("panel.actionType")} <span aria-hidden="true" className="text-danger">*</span>
+          <span className="sr-only"> ({t("common:labels.required")})</span>
+        </Label>
+        <SearchableSelect
+          id={actionTypeId}
+          required
+          options={buildActionTypeOptions(constants.actionTypes)}
+          value={action.type || null}
+          onValueChange={(v) => v && onTypeChange(v)}
+          placeholder={t("panel.selectAction")}
+          searchPlaceholder={t("panel.search")}
+          noResultsLabel={t("panel.noResults")}
+        />
+      </div>
 
-  const handleFieldChange = (key: string, value: unknown) => {
-    const updated = setNestedValue(
-      action as unknown as Record<string, unknown>,
-      key,
-      value,
-    ) as unknown as ActionConfig;
-    onActionChange(index, updated);
-  };
+      {action.type && fields.length > 0 && (
+        <ActionFields
+          fields={fields}
+          values={action as unknown as Record<string, unknown>}
+          onChange={onFieldChange}
+          channels={channels}
+          roles={roles}
+          variables={variables}
+          actionType={action.type}
+          // Required fields block Save, so the panel has to say which one is
+          // empty — a red asterisk alone left screen-reader users with no way
+          // to tell why the button was disabled.
+          showErrors
+        />
+      )}
+
+      {(action.type === "sendMessage" || action.type === "sendDM") && (
+        <div className="mt-2">
+          <DiscordMessagePreview
+            variables={variables}
+            real={real}
+            content={action.message ?? ""}
+          />
+        </div>
+      )}
+      {action.type === "sendEmbed" && (
+        <div className="mt-2">
+          <DiscordMessagePreview
+            variables={variables}
+            real={real}
+            embed={{
+              title: action.embed?.title,
+              description: action.embed?.description,
+              footer: action.embed?.footer,
+              color: action.embed?.color,
+            }}
+          />
+        </div>
+      )}
+    </>
+  );
+}
 
+/** Settings/Variables tab shell shared by both action editors. */
+function ActionTabs({
+  eventType,
+  constants,
+  children,
+}: {
+  eventType: string;
+  constants: Constants;
+  children: React.ReactNode;
+}) {
+  const { t } = useTranslation(["rules", "common"]);
   return (
     <Tabs defaultValue="settings">
       <TabsList className="w-full">
@@ -344,94 +456,16 @@ function ActionPanel({
       </TabsList>
 
       <TabsContent value="settings">
-        <div className="space-y-4">
-          <div>
-            <Label>
-              {t("panel.actionType")} <span aria-hidden="true" className="text-danger">*</span>
-              <span className="sr-only"> ({t("common:labels.required")})</span>
-            </Label>
-            <SearchableSelect
-              options={buildActionTypeOptions(constants.actionTypes)}
-              value={action.type || null}
-              onValueChange={(v) => v && handleTypeChange(v)}
-              placeholder={t("panel.selectAction")}
-              searchPlaceholder={t("panel.search")}
-              noResultsLabel={t("panel.noResults")}
-            />
-          </div>
-
-          {action.type && fields.length > 0 && (
-            <ActionFields
-              fields={fields}
-              values={action as unknown as Record<string, unknown>}
-              onChange={handleFieldChange}
-              channels={channels}
-              roles={roles}
-              variables={variables}
-            />
-          )}
-
-          {(action.type === "sendMessage" || action.type === "sendDM") && (
-            <div className="mt-2">
-              <DiscordMessagePreview
-                variables={variables}
-                real={real}
-                content={action.message ?? ""}
-              />
-            </div>
-          )}
-          {action.type === "sendEmbed" && (
-            <div className="mt-2">
-              <DiscordMessagePreview
-                variables={variables}
-                real={real}
-                embed={{
-                  title: action.embed?.title,
-                  description: action.embed?.description,
-                  footer: action.embed?.footer,
-                  color: action.embed?.color,
-                }}
-              />
-            </div>
-          )}
-
-          {totalActions > 1 && (
-            <div className="flex gap-2 border-t border-border pt-3">
-              <Button
-                variant="ghost"
-                size="sm"
-                className="flex-1"
-                disabled={index === 0}
-                onClick={() => onActionMove(index, "up")}
-              >
-                <Icon name="arrow_upward" size={16} />
-                {t("panel.moveUp")}
-              </Button>
-              <Button
-                variant="ghost"
-                size="sm"
-                className="flex-1"
-                disabled={index === totalActions - 1}
-                onClick={() => onActionMove(index, "down")}
-              >
-                <Icon name="arrow_downward" size={16} />
-                {t("panel.moveDown")}
-              </Button>
-            </div>
-          )}
-
-          {canRemove && (
-            <RemoveButton
-              label={t("panel.removeAction")}
-              onConfirm={() => onActionRemove(index)}
-            />
-          )}
-        </div>
+        <div className="space-y-4">{children}</div>
       </TabsContent>
 
       <TabsContent value="variables">
+        {/* Scoped to the selected trigger, exactly like the trigger panel's own
+            tab. Listing every token in the system contradicted both the
+            autocomplete beside it and the editor's unknown-token validator,
+            and invited templates the bot renders as "Unknown". */}
         <VariablesTab
-          variables={Object.keys(constants.templateVariables)}
+          variables={eventType ? (constants.eventTypeVariables[eventType] ?? []) : []}
           constants={constants}
         />
       </TabsContent>
@@ -439,6 +473,87 @@ function ActionPanel({
   );
 }
 
+function ActionPanel({
+  index,
+  action,
+  constants,
+  guildId,
+  eventType,
+  totalActions,
+  onActionChange,
+  onActionRemove,
+  onActionMove,
+  canRemove,
+}: ActionPanelProps) {
+  const { t } = useTranslation(["rules", "common"]);
+  const variables = buildAutomationVariables(constants, eventType);
+
+  const handleTypeChange = (newType: string) => {
+    onActionChange(
+      index,
+      carryOverActionFields(
+        action as unknown as Record<string, unknown>,
+        newType,
+        constants.actionTypeFields,
+      ) as unknown as ActionConfig,
+    );
+  };
+
+  const handleFieldChange = (key: string, value: unknown) => {
+    const updated = setNestedValue(
+      action as unknown as Record<string, unknown>,
+      key,
+      value,
+    ) as unknown as ActionConfig;
+    onActionChange(index, updated);
+  };
+
+  return (
+    <ActionTabs eventType={eventType} constants={constants}>
+      <ActionSettings
+        action={action}
+        constants={constants}
+        guildId={guildId}
+        variables={variables}
+        onTypeChange={handleTypeChange}
+        onFieldChange={handleFieldChange}
+      />
+
+      {totalActions > 1 && (
+        <div className="flex gap-2 border-t border-border pt-3">
+          <Button
+            variant="ghost"
+            size="sm"
+            className="flex-1"
+            disabled={index === 0}
+            onClick={() => onActionMove(index, "up")}
+          >
+            <Icon name="arrow_upward" size={16} />
+            {t("panel.moveUp")}
+          </Button>
+          <Button
+            variant="ghost"
+            size="sm"
+            className="flex-1"
+            disabled={index === totalActions - 1}
+            onClick={() => onActionMove(index, "down")}
+          >
+            <Icon name="arrow_downward" size={16} />
+            {t("panel.moveDown")}
+          </Button>
+        </div>
+      )}
+
+      {canRemove && (
+        <RemoveButton
+          label={t("panel.removeAction")}
+          onConfirm={() => onActionRemove(index)}
+        />
+      )}
+    </ActionTabs>
+  );
+}
+
 const CONDITION_FIELDS: Array<{ value: string; labelKey: string }> = [
   { value: "channelId", labelKey: "conditionFields.channelId" },
   { value: "channelName", labelKey: "conditionFields.channelName" },
@@ -471,8 +586,9 @@ const END_TARGET = "__end__";
 function stepShortLabel(step: RuleStep, constants: Constants, t: TFunction): string {
   if (step.type === "action") {
     return (
-      constants.actionTypes[step.action.type]?.label ??
-      (step.action.type || t("nodes.selectAction"))
+      (step.action.type
+        ? makeAutomationLabels(t as unknown as TranslateFn, constants).actionLabel(step.action.type)
+        : t("nodes.selectAction"))
     );
   }
   if (step.type === "condition") {
@@ -535,17 +651,20 @@ function StepPanel({
   onStepRemove,
 }: StepPanelProps) {
   const { t } = useTranslation(["rules", "common"]);
-  const { data: channels = [] } = useChannels(guildId);
-  const { data: roles = [] } = useRoles(guildId);
   const variables = buildAutomationVariables(constants, eventType);
   const step = steps.find((s) => s.id === stepId);
   if (!step) return <p className="text-xs text-text-muted">{t("panel.stepNotFound")}</p>;
 
   if (step.type === "action") {
-    const fields = constants.actionTypeFields[step.action.type] ?? [];
-
     const handleTypeChange = (newType: string) => {
-      onStepChange(stepId, { ...step, action: { type: newType } });
+      onStepChange(stepId, {
+        ...step,
+        action: carryOverActionFields(
+          step.action as unknown as Record<string, unknown>,
+          newType,
+          constants.actionTypeFields,
+        ) as unknown as typeof step.action,
+      });
     };
 
     const handleFieldChange = (key: string, value: unknown) => {
@@ -558,32 +677,15 @@ function StepPanel({
     };
 
     return (
-      <div className="space-y-4">
-        <div>
-          <Label>
-            {t("panel.actionType")} <span aria-hidden="true" className="text-danger">*</span>
-              <span className="sr-only"> ({t("common:labels.required")})</span>
-          </Label>
-          <SearchableSelect
-            options={buildActionTypeOptions(constants.actionTypes)}
-            value={step.action.type || null}
-            onValueChange={(v) => v && handleTypeChange(v)}
-            placeholder={t("panel.selectAction")}
-            searchPlaceholder={t("panel.search")}
-            noResultsLabel={t("panel.noResults")}
-          />
-        </div>
-
-        {step.action.type && fields.length > 0 && (
-          <ActionFields
-            fields={fields}
-            values={step.action as unknown as Record<string, unknown>}
-            onChange={handleFieldChange}
-            channels={channels}
-            roles={roles}
-            variables={variables}
-          />
-        )}
+      <ActionTabs eventType={eventType} constants={constants}>
+        <ActionSettings
+          action={step.action}
+          constants={constants}
+          guildId={guildId}
+          variables={variables}
+          onTypeChange={handleTypeChange}
+          onFieldChange={handleFieldChange}
+        />
 
         <div className="space-y-3 border-t border-border pt-3">
           <span className="section-label text-text-muted">{t("panel.connections")}</span>
@@ -601,7 +703,7 @@ function StepPanel({
           label={t("panel.removeStep")}
           onConfirm={() => onStepRemove(stepId)}
         />
-      </div>
+      </ActionTabs>
     );
   }
 
diff --git a/apps/dashboard/src/client/features/automation/workflow/WorkflowEditor.tsx b/apps/dashboard/src/client/features/automation/workflow/WorkflowEditor.tsx
index 31896ac1..43ce948d 100644
--- a/apps/dashboard/src/client/features/automation/workflow/WorkflowEditor.tsx
+++ b/apps/dashboard/src/client/features/automation/workflow/WorkflowEditor.tsx
@@ -1,4 +1,4 @@
-import { useState, useCallback, useMemo, useEffect, useRef } from "react";
+import { useState, useCallback, useMemo, useEffect, useRef, useId } from "react";
 import { useTranslation } from "react-i18next";
 import { createPortal } from "react-dom";
 import { useParams } from "@tanstack/react-router";
@@ -59,6 +59,8 @@ import {
   TooltipProvider,
 } from "../../../shared/ui/tooltip";
 import { PageSkeleton } from "../../../shared/ui/skeletons";
+import { Popover, PopoverContent, PopoverTrigger } from "../../../shared/ui/popover";
+import { ConfirmDialog } from "../../../shared/components/ConfirmDialog";
 
 export interface RuleDraft {
   name: string;
@@ -119,6 +121,7 @@ function WorkflowEditorInner({ rule, draft, onClose }: WorkflowEditorProps) {
   const [error, setError] = useState("");
   const [selectedNode, setSelectedNode] = useState<SelectedNode | null>(null);
   const [draftRestored, setDraftRestored] = useState(!!savedDraft);
+  const [confirmDiscard, setConfirmDiscard] = useState(false);
 
   const emptyAction: ActionConfig = { type: "" };
 
@@ -136,6 +139,7 @@ function WorkflowEditorInner({ rule, draft, onClose }: WorkflowEditorProps) {
     handleEdgeRemoval,
     handleActionChange: rawActionChange,
     handleActionRemove: rawActionRemove,
+    handleActionsRemove: rawActionsRemove,
     handleActionMove: rawActionMove,
     convertAndSeverEdges,
     duplicateNode,
@@ -178,10 +182,51 @@ function WorkflowEditorInner({ rule, draft, onClose }: WorkflowEditorProps) {
     });
   }, [rawActionMove, actions.length]);
 
-  // Auto-save draft on changes
+  /**
+   * Snapshot of the state the editor opened with, for the dirty check below.
+   * Captured once — a ref, not state, so it never re-renders and never drifts.
+   */
+  const openedWithRef = useRef(
+    JSON.stringify({ name, eventType, actions, steps, entryStepId, conditions, priority, enabled }),
+  );
+
+  const isDirty =
+    JSON.stringify({ name, eventType, actions, steps, entryStepId, conditions, priority, enabled }) !==
+    openedWithRef.current;
+
+  // Auto-save draft on changes.
+  //
+  // Only for NEW rules: `loadDraft` is consulted solely when there is no
+  // `rule`, so writing one while editing an existing rule produced an unread
+  // draft that sat in localStorage until it expired — and gave the false
+  // impression the edits were recoverable. They were not; the guard on close
+  // is what actually protects them.
   useEffect(() => {
+    if (rule) return;
+    // Nothing worth restoring yet: the autosave otherwise fired 500ms after
+    // mount with the untouched initial state, so the next "Create Rule" was
+    // greeted by a "draft restored" banner for an empty draft.
+    if (!isDirty) return;
     saveDraftToStorage({ name, eventType, actions, steps, entryStepId, conditions, priority, enabled });
-  }, [name, eventType, actions, steps, entryStepId, conditions, priority, enabled, saveDraftToStorage]);
+  }, [rule, isDirty, name, eventType, actions, steps, entryStepId, conditions, priority, enabled, saveDraftToStorage]);
+
+  // Browser-level guard for a tab close or reload, which no in-app dialog can
+  // intercept.
+  useEffect(() => {
+    if (!isDirty) return;
+    const onBeforeUnload = (e: BeforeUnloadEvent) => e.preventDefault();
+    window.addEventListener("beforeunload", onBeforeUnload);
+    return () => window.removeEventListener("beforeunload", onBeforeUnload);
+  }, [isDirty]);
+
+  /** Close, but never silently drop unsaved work. */
+  const requestClose = useCallback(() => {
+    if (isDirty) {
+      setConfirmDiscard(true);
+      return;
+    }
+    onClose();
+  }, [isDirty, onClose]);
 
   const validation = useMemo(
     () => validateWorkflow(eventType, actions, name, constants ?? undefined, t, steps, entryStepId),
@@ -213,6 +258,7 @@ function WorkflowEditorInner({ rule, draft, onClose }: WorkflowEditorProps) {
     // node the menu's verbs will act on), not keep the ring on A. The panel
     // selection gets the ring back the moment the menu closes.
     selectedNodeId: contextMenu.contextMenuNodeId ?? selectedNodeId,
+    conditions,
     onAddAction: addAction,
     validationIssues: validation.issues,
     t,
@@ -228,26 +274,28 @@ function WorkflowEditorInner({ rule, draft, onClose }: WorkflowEditorProps) {
   const onNodesChange: OnNodesChange = useCallback((changes) => {
     const removals = changes.filter((c) => c.type === "remove");
     if (removals.length > 0) {
+      // A multi-select Delete arrives as several `remove` changes at once.
+      // Applying them one at a time by index was wrong: each removal splices
+      // the array, so from the second onward the index pointed at a different
+      // action and the wrong nodes disappeared. Collect first, remove once.
+      const actionIndices: number[] = [];
+      const stepIds: string[] = [];
       for (const change of removals) {
         if (change.type !== "remove") continue;
         const nodeId = change.id;
         if (nodeId.startsWith("action-") && !isStepMode) {
           const index = parseInt(nodeId.split("-")[1], 10);
-          if (!isNaN(index)) {
-            if (actions.length > 1) {
-              handleActionRemove(index);
-            } else {
-              // Last action — reset to empty instead of removing
-              rawActionChange(index, { type: "" });
-              setSelectedNode(null);
-            }
-          }
+          if (!isNaN(index)) actionIndices.push(index);
         } else if (nodeId.startsWith("step-")) {
-          const stepId = nodeId.slice(5);
-          handleStepRemove(stepId);
+          stepIds.push(nodeId.slice(5));
         }
         // Ignore trigger/add-action node removals
       }
+      if (actionIndices.length > 0) {
+        rawActionsRemove(actionIndices);
+        setSelectedNode(null);
+      }
+      for (const stepId of stepIds) handleStepRemove(stepId);
       // Don't pass removals to React Flow — our sync effect handles the visual update
       const nonRemovals = changes.filter((c) => c.type !== "remove");
       if (nonRemovals.length > 0) {
@@ -256,7 +304,7 @@ function WorkflowEditorInner({ rule, draft, onClose }: WorkflowEditorProps) {
       return;
     }
     onNodesChangeBase(changes);
-  }, [isStepMode, actions.length, handleActionRemove, rawActionChange, handleStepRemove, onNodesChangeBase]);
+  }, [isStepMode, rawActionsRemove, handleStepRemove, onNodesChangeBase]);
 
   // Custom edge change handler: intercept edge removals and update step data
   const onEdgesChange: OnEdgesChange = useCallback((changes) => {
@@ -435,6 +483,27 @@ function WorkflowEditorInner({ rule, draft, onClose }: WorkflowEditorProps) {
     }
   }, [name, eventType, actions, steps, entryStepId, isStepMode, conditions, priority, enabled, rule, createRule, updateRule, onClose, clearDraft, t, validation.valid]);
 
+  const saveBlockedId = useId();
+
+  /**
+   * Selects and centres the node an issue belongs to, so the issue list is a
+   * way to reach the problem rather than just a description of it.
+   */
+  const focusIssueNode = useCallback((nodeId: string) => {
+    const parsed = parseNodeId(nodeId);
+    if (parsed?.kind === "trigger") setSelectedNode({ type: "trigger" });
+    else if (parsed?.kind === "action") setSelectedNode({ type: "action", index: parsed.index });
+    else if (parsed?.kind === "step") setSelectedNode({ type: "step", stepId: parsed.stepId });
+    else return; // "toolbar" issues (e.g. the rule name) have no node
+    const node = reactFlowInstance.current?.getNode(nodeId);
+    if (node) {
+      reactFlowInstance.current?.setCenter(node.position.x + 110, node.position.y + 40, {
+        zoom: 1,
+        duration: 300,
+      });
+    }
+  }, []);
+
   const handleFitView = useCallback(() => {
     reactFlowInstance.current?.fitView({ padding: 0.3, duration: 300 });
   }, []);
@@ -550,7 +619,7 @@ function WorkflowEditorInner({ rule, draft, onClose }: WorkflowEditorProps) {
     isStepMode,
     actionsLength: actions.length,
     contextMenuOpen: contextMenu.menu !== null,
-    onClose,
+    onClose: requestClose,
     onDeselectNode: () => setSelectedNode(null),
     onSubmit: handleSubmit,
     onFitView: handleFitView,
@@ -583,7 +652,7 @@ function WorkflowEditorInner({ rule, draft, onClose }: WorkflowEditorProps) {
       `}</style>
       {/* Floating toolbar */}
       <div className="flex flex-wrap items-center gap-2 border-b border-border bg-surface-low/90 px-3 py-2 backdrop-blur-sm sm:gap-3 sm:px-4 sm:py-2.5">
-        <Button variant="ghost" size="sm" onClick={onClose} className="gap-1.5">
+        <Button variant="ghost" size="sm" onClick={requestClose} className="gap-1.5">
           <Icon name="arrow_back" size={16} className="rtl:rotate-180" />
           <span className="hidden text-text-muted sm:inline">{t("editor.backToRules")}</span>
         </Button>
@@ -629,7 +698,12 @@ function WorkflowEditorInner({ rule, draft, onClose }: WorkflowEditorProps) {
             variant="ghost"
             size="sm"
             onClick={addAction}
-            disabled={!isStepMode && actions.length >= constants.maxActionsPerRule}
+            disabled={
+              isStepMode
+                ? (steps?.filter((s) => s.type === "action").length ?? 0) >=
+                  constants.maxActionsPerRule
+                : actions.length >= constants.maxActionsPerRule
+            }
           >
             <Icon name="add" size={16} />
             {t("editor.addAction")}
@@ -638,6 +712,13 @@ function WorkflowEditorInner({ rule, draft, onClose }: WorkflowEditorProps) {
             variant="ghost"
             size="sm"
             onClick={addConditionStep}
+            // The server caps conditions at 3 and total steps at 10; without
+            // the same ceiling here the rule was only rejected at save time,
+            // in raw untranslated English, after the work was done.
+            disabled={
+              (steps?.filter((s) => s.type === "condition").length ?? 0) >= 3 ||
+              (steps?.length ?? 0) >= 10
+            }
           >
             <Icon name="call_split" size={16} className="text-warning" />
             {t("editor.addCondition")}
@@ -646,44 +727,57 @@ function WorkflowEditorInner({ rule, draft, onClose }: WorkflowEditorProps) {
             variant="ghost"
             size="sm"
             onClick={addDelayStep}
+            disabled={(steps?.length ?? 0) >= 10}
           >
             <Icon name="schedule" size={16} className="text-text-muted" />
             {t("editor.addDelay")}
           </Button>
           <Separator orientation="vertical" className="h-5" />
 
-          {/* Validation status */}
+          {/* Validation status.
+              Previously a tooltip on a non-focusable div: keyboard and screen
+              reader users had no way to read it, the disabled Save button gave
+              no reason at all, and with five actions there was no way to tell
+              WHICH one was incomplete without opening each. Now a popover on a
+              real button, with each issue a link that selects its node. */}
           {validation.issues.length > 0 ? (
-            <TooltipProvider>
-              <Tooltip>
-                <TooltipTrigger asChild>
-                  <div className="flex items-center gap-1.5 text-xs">
-                    <Icon
-                      name={validation.valid ? "warning" : "error"}
-                      size={16}
-                      className={validation.valid ? "text-warning" : "text-danger"}
-                    />
-                    <span className={validation.valid ? "text-warning" : "text-danger"}>
-                      {t("editor.issues", { count: validation.issues.length })}
-                    </span>
-                  </div>
-                </TooltipTrigger>
-                <TooltipContent side="bottom" className="max-w-72">
-                  <ul className="space-y-1 text-xs">
-                    {validation.issues.map((issue, i) => (
-                      <li key={i} className="flex items-start gap-1.5">
+            <Popover>
+              <PopoverTrigger asChild>
+                <Button
+                  variant="ghost"
+                  size="sm"
+                  className={`gap-1.5 ${validation.valid ? "text-warning" : "text-danger"}`}
+                >
+                  <Icon name={validation.valid ? "warning" : "error"} size={16} />
+                  {t("editor.issues", { count: validation.issues.length })}
+                </Button>
+              </PopoverTrigger>
+              <PopoverContent align="end" className="w-80 p-2">
+                <p className="px-2 pb-2 text-xs text-text-secondary">
+                  {validation.valid
+                    ? t("editor.issuesWarningHint")
+                    : t("editor.issuesErrorHint")}
+                </p>
+                <ul className="space-y-0.5">
+                  {validation.issues.map((issue, i) => (
+                    <li key={i}>
+                      <button
+                        type="button"
+                        onClick={() => focusIssueNode(issue.nodeId)}
+                        className="flex w-full items-start gap-1.5 rounded px-2 py-1.5 text-start text-xs hover:bg-surface-high focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+                      >
                         <Icon
                           name={issue.level === "error" ? "error" : "warning"}
                           size={12}
-                          className={issue.level === "error" ? "text-danger" : "text-warning"}
+                          className={`mt-0.5 shrink-0 ${issue.level === "error" ? "text-danger" : "text-warning"}`}
                         />
                         {issue.message}
-                      </li>
-                    ))}
-                  </ul>
-                </TooltipContent>
-              </Tooltip>
-            </TooltipProvider>
+                      </button>
+                    </li>
+                  ))}
+                </ul>
+              </PopoverContent>
+            </Popover>
           ) : name.trim() && eventType && actions.length > 0 ? (
             <div className="flex items-center gap-1.5 text-xs text-secondary">
               <Icon name="check_circle" size={16} />
@@ -691,10 +785,24 @@ function WorkflowEditorInner({ rule, draft, onClose }: WorkflowEditorProps) {
             </div>
           ) : null}
 
-          <Button size="sm" onClick={handleSubmit} disabled={isPending || !validation.valid}>
+          <Button
+            size="sm"
+            onClick={handleSubmit}
+            disabled={isPending || !validation.valid}
+            // A disabled control with no announced reason is a dead end for
+            // anyone who cannot see the issue count beside it.
+            aria-describedby={!validation.valid ? saveBlockedId : undefined}
+          >
             <Icon name={rule ? "save" : "check"} size={16} />
             {isPending ? t("form.saving") : rule ? t("form.update") : t("form.create")}
           </Button>
+          {!validation.valid && (
+            <span id={saveBlockedId} className="sr-only">
+              {t("editor.saveBlocked", {
+                count: validation.issues.filter((i) => i.level === "error").length,
+              })}
+            </span>
+          )}
         </div>
       </div>
 
@@ -811,6 +919,19 @@ function WorkflowEditorInner({ rule, draft, onClose }: WorkflowEditorProps) {
           </Panel>
         </ReactFlow>
 
+        <ConfirmDialog
+          open={confirmDiscard}
+          onOpenChange={setConfirmDiscard}
+          title={t("editor.discardChangesTitle")}
+          description={t("editor.discardChangesDescription")}
+          confirmLabel={t("editor.discardChanges")}
+          onConfirm={() => {
+            clearDraft();
+            onClose();
+          }}
+          destructive
+        />
+
         {contextMenu.menu && (
           <WorkflowContextMenu
             open
diff --git a/apps/dashboard/src/client/features/automation/workflow/nodes/ActionNode.tsx b/apps/dashboard/src/client/features/automation/workflow/nodes/ActionNode.tsx
index 180d93a9..1bff9f20 100644
--- a/apps/dashboard/src/client/features/automation/workflow/nodes/ActionNode.tsx
+++ b/apps/dashboard/src/client/features/automation/workflow/nodes/ActionNode.tsx
@@ -21,6 +21,32 @@ function getBorderClass(
   return "border-outline-variant/10 bg-surface-low";
 }
 
+/**
+ * Non-colour signal for a node's validation state.
+ *
+ * Colour alone cannot carry this: a condition node's brand colour already IS
+ * amber, so a "warning" border is indistinguishable from its normal styling —
+ * and colour-only status fails WCAG 1.4.1 regardless. The data attribute also
+ * gives the toolbar's issue list something to scroll to.
+ */
+function ValidationBadge({
+  state,
+}: {
+  state: "valid" | "warning" | "error" | null | undefined;
+}) {
+  const { t } = useTranslation("rules");
+  if (state !== "warning" && state !== "error") return null;
+  return (
+    <span
+      role="img"
+      aria-label={t(state === "error" ? "nodes.hasError" : "nodes.hasWarning")}
+      className={`ms-auto ${state === "error" ? "text-danger" : "text-warning"}`}
+    >
+      <Icon name={state === "error" ? "error" : "warning"} size={14} />
+    </span>
+  );
+}
+
 function ActionNodeComponent({ data, selected }: NodeProps) {
   const { t } = useTranslation("rules");
   const { index, action, label, validationState } = data as ActionNodeData;
@@ -38,6 +64,7 @@ function ActionNodeComponent({ data, selected }: NodeProps) {
       />
       <div
         role="group"
+        data-validation={validationState ?? undefined}
         aria-label={t("nodes.ariaAction", { index: index + 1, label })}
         className={`min-w-[220px] max-w-[260px] rounded-lg border px-4 py-3 transition-all glass-edge ${getBorderClass(selected, validationState)}`}
       >
@@ -48,6 +75,7 @@ function ActionNodeComponent({ data, selected }: NodeProps) {
           <span className="section-label text-text-muted">
             {t("nodes.action", { index: index + 1 })}
           </span>
+          <ValidationBadge state={validationState} />
           {validationState === "error" && (
             <Icon name="error" size={14} className="ms-auto text-danger" />
           )}
diff --git a/apps/dashboard/src/client/features/automation/workflow/nodes/ConditionNode.tsx b/apps/dashboard/src/client/features/automation/workflow/nodes/ConditionNode.tsx
index f25797ce..f2ee77cc 100644
--- a/apps/dashboard/src/client/features/automation/workflow/nodes/ConditionNode.tsx
+++ b/apps/dashboard/src/client/features/automation/workflow/nodes/ConditionNode.tsx
@@ -41,6 +41,32 @@ function getBorderClass(
   return "border-warning/30 bg-warning/5";
 }
 
+/**
+ * Non-colour signal for a node's validation state.
+ *
+ * Colour alone cannot carry this: a condition node's brand colour already IS
+ * amber, so a "warning" border is indistinguishable from its normal styling —
+ * and colour-only status fails WCAG 1.4.1 regardless. The data attribute also
+ * gives the toolbar's issue list something to scroll to.
+ */
+function ValidationBadge({
+  state,
+}: {
+  state: "valid" | "warning" | "error" | null | undefined;
+}) {
+  const { t } = useTranslation("rules");
+  if (state !== "warning" && state !== "error") return null;
+  return (
+    <span
+      role="img"
+      aria-label={t(state === "error" ? "nodes.hasError" : "nodes.hasWarning")}
+      className={`ms-auto ${state === "error" ? "text-danger" : "text-warning"}`}
+    >
+      <Icon name={state === "error" ? "error" : "warning"} size={14} />
+    </span>
+  );
+}
+
 function ConditionNodeComponent({ data, selected }: NodeProps) {
   const { t } = useTranslation("rules");
   const { field, operator, value, label, validationState } =
@@ -59,6 +85,7 @@ function ConditionNodeComponent({ data, selected }: NodeProps) {
       />
       <div
         role="group"
+        data-validation={validationState ?? undefined}
         aria-label={t("nodes.ariaCondition", { label })}
         className={`min-w-[200px] max-w-[260px] rounded-lg border-2 px-4 py-3 transition-all ${getBorderClass(selected, validationState)}`}
       >
@@ -69,6 +96,7 @@ function ConditionNodeComponent({ data, selected }: NodeProps) {
           <span className="section-label text-warning">
             {t("nodes.condition")}
           </span>
+          <ValidationBadge state={validationState} />
           {!isConfigured && (
             <span
               role="img"
diff --git a/apps/dashboard/src/client/features/automation/workflow/nodes/DelayNode.tsx b/apps/dashboard/src/client/features/automation/workflow/nodes/DelayNode.tsx
index d6d158f2..28c89400 100644
--- a/apps/dashboard/src/client/features/automation/workflow/nodes/DelayNode.tsx
+++ b/apps/dashboard/src/client/features/automation/workflow/nodes/DelayNode.tsx
@@ -33,6 +33,32 @@ function getBorderClass(
   return "border-text-muted/20 bg-surface-low";
 }
 
+/**
+ * Non-colour signal for a node's validation state.
+ *
+ * Colour alone cannot carry this: a condition node's brand colour already IS
+ * amber, so a "warning" border is indistinguishable from its normal styling —
+ * and colour-only status fails WCAG 1.4.1 regardless. The data attribute also
+ * gives the toolbar's issue list something to scroll to.
+ */
+function ValidationBadge({
+  state,
+}: {
+  state: "valid" | "warning" | "error" | null | undefined;
+}) {
+  const { t } = useTranslation("rules");
+  if (state !== "warning" && state !== "error") return null;
+  return (
+    <span
+      role="img"
+      aria-label={t(state === "error" ? "nodes.hasError" : "nodes.hasWarning")}
+      className={`ms-auto ${state === "error" ? "text-danger" : "text-warning"}`}
+    >
+      <Icon name={state === "error" ? "error" : "warning"} size={14} />
+    </span>
+  );
+}
+
 function DelayNodeComponent({ data, selected }: NodeProps) {
   const { t } = useTranslation("rules");
   const { delayMs, label, validationState } = data as DelayNodeData;
@@ -47,6 +73,7 @@ function DelayNodeComponent({ data, selected }: NodeProps) {
       />
       <div
         role="group"
+        data-validation={validationState ?? undefined}
         aria-label={t("nodes.ariaDelay", { label })}
         className={`min-w-[160px] max-w-[220px] rounded-lg border-2 px-4 py-3 transition-all ${getBorderClass(selected, validationState)}`}
       >
@@ -57,6 +84,7 @@ function DelayNodeComponent({ data, selected }: NodeProps) {
           <span className="section-label text-text-muted">
             {t("nodes.delay")}
           </span>
+          <ValidationBadge state={validationState} />
         </div>
         <p className="text-sm font-medium text-text">{label}</p>
         <p className="mt-0.5 text-xs text-text-muted">
diff --git a/apps/dashboard/src/client/features/automation/workflow/nodes/TriggerNode.tsx b/apps/dashboard/src/client/features/automation/workflow/nodes/TriggerNode.tsx
index 024bfab1..6832150b 100644
--- a/apps/dashboard/src/client/features/automation/workflow/nodes/TriggerNode.tsx
+++ b/apps/dashboard/src/client/features/automation/workflow/nodes/TriggerNode.tsx
@@ -20,14 +20,41 @@ function getBorderClass(
   return "border-accent/40 bg-accent/5";
 }
 
+/**
+ * Non-colour signal for a node's validation state.
+ *
+ * Colour alone cannot carry this: a condition node's brand colour already IS
+ * amber, so a "warning" border is indistinguishable from its normal styling —
+ * and colour-only status fails WCAG 1.4.1 regardless. The data attribute also
+ * gives the toolbar's issue list something to scroll to.
+ */
+function ValidationBadge({
+  state,
+}: {
+  state: "valid" | "warning" | "error" | null | undefined;
+}) {
+  const { t } = useTranslation("rules");
+  if (state !== "warning" && state !== "error") return null;
+  return (
+    <span
+      role="img"
+      aria-label={t(state === "error" ? "nodes.hasError" : "nodes.hasWarning")}
+      className={`ms-auto ${state === "error" ? "text-danger" : "text-warning"}`}
+    >
+      <Icon name={state === "error" ? "error" : "warning"} size={14} />
+    </span>
+  );
+}
+
 function TriggerNodeComponent({ data, selected }: NodeProps) {
   const { t } = useTranslation("rules");
-  const { label, description, validationState } = data as TriggerNodeData;
+  const { label, description, validationState, filterCount } = data as TriggerNodeData;
 
   return (
     <>
       <div
         role="group"
+        data-validation={validationState ?? undefined}
         aria-label={t("nodes.ariaTrigger", { label })}
         className={`min-w-[220px] max-w-[260px] rounded-lg border-2 px-4 py-3 transition-all ${getBorderClass(selected, validationState)}`}
       >
@@ -38,11 +65,15 @@ function TriggerNodeComponent({ data, selected }: NodeProps) {
           <span className="section-label text-accent">
             {t("nodes.trigger")}
           </span>
-          {validationState === "error" && (
-            <Icon name="error" size={14} className="ms-auto text-danger" />
-          )}
-          {validationState === "warning" && (
-            <Icon name="warning" size={14} className="ms-auto text-warning" />
+          <ValidationBadge state={validationState} />
+          {!!filterCount && (
+            <span
+              className="ms-auto flex items-center gap-1 rounded bg-surface-high px-1.5 py-0.5 text-[10px] text-text-secondary"
+              aria-label={t("nodes.activeFilters", { count: filterCount })}
+            >
+              <Icon name="filter_alt" size={11} />
+              {filterCount}
+            </span>
           )}
         </div>
         <p className="text-sm font-medium text-text">{label}</p>
diff --git a/apps/dashboard/src/client/features/automation/workflow/useWorkflowKeyboard.ts b/apps/dashboard/src/client/features/automation/workflow/useWorkflowKeyboard.ts
index 35312ed8..00d84292 100644
--- a/apps/dashboard/src/client/features/automation/workflow/useWorkflowKeyboard.ts
+++ b/apps/dashboard/src/client/features/automation/workflow/useWorkflowKeyboard.ts
@@ -50,9 +50,26 @@ export function useWorkflowKeyboard({
       // Defence in depth: a key an overlay already handled (and cancelled)
       // must not be re-interpreted as an editor hotkey.
       if (e.defaultPrevented) return;
-      const tag = e.target instanceof HTMLElement ? e.target.tagName : undefined;
-      if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT") {
-        if (e.key !== "Escape" && !(e.key === "s" && (e.metaKey || e.ctrlKey))) return;
+      const target = e.target instanceof HTMLElement ? e.target : null;
+      const tag = target?.tagName;
+      const inField =
+        tag === "INPUT" ||
+        tag === "TEXTAREA" ||
+        tag === "SELECT" ||
+        target?.isContentEditable === true;
+
+      if (inField) {
+        // Escape belongs to the field, not the editor. It used to fall through
+        // to the editor-level binding below, so typing a rule name and hitting
+        // Escape out of habit tore down the whole full-screen editor — and for
+        // an existing rule that discarded every unsaved edit, because the
+        // per-rule draft is never read back. Blur and stop.
+        if (e.key === "Escape") {
+          target?.blur();
+          return;
+        }
+        // Everything else stays typeable; only the save shortcut passes through.
+        if (!(e.key === "s" && (e.metaKey || e.ctrlKey))) return;
       }
 
       if (e.key === "Escape") {
diff --git a/apps/dashboard/src/client/features/automation/workflow/useWorkflowNodes.ts b/apps/dashboard/src/client/features/automation/workflow/useWorkflowNodes.ts
index f58f40e5..62ee8d17 100644
--- a/apps/dashboard/src/client/features/automation/workflow/useWorkflowNodes.ts
+++ b/apps/dashboard/src/client/features/automation/workflow/useWorkflowNodes.ts
@@ -3,6 +3,8 @@ import type { Node, Edge } from "@xyflow/react";
 import type { ActionConfig, Constants, RuleStep } from "../../../shared/lib/schemas";
 import type { TranslateFn, ValidationIssue } from "../lib/workflow-validation";
 import { getNodeValidationState } from "../lib/workflow-validation";
+import { makeAutomationLabels } from "../lib/labels";
+import type { ActionConditions } from "../../../shared/lib/schemas";
 import type { ConditionNodeData } from "./nodes/ConditionNode";
 import type { DelayNodeData } from "./nodes/DelayNode";
 
@@ -16,6 +18,8 @@ interface WorkflowNodesInput {
   selectedNodeId?: string | null;
   onAddAction?: () => void;
   validationIssues?: ValidationIssue[];
+  /** Trigger filters, so the trigger node can show how many are active. */
+  conditions?: ActionConditions;
   /** Translator (rules namespace) for node labels built outside React components. */
   t: TranslateFn;
 }
@@ -25,6 +29,8 @@ export interface TriggerNodeData {
   label: string;
   description: string;
   validationState?: "valid" | "warning" | "error" | null;
+  /** Number of active trigger filters, surfaced as a badge on the node. */
+  filterCount?: number;
   [key: string]: unknown;
 }
 
@@ -63,11 +69,12 @@ function buildLinearNodes(
   triggerNode: Node<TriggerNodeData>,
 ): { nodes: Node[]; edges: Edge[] } {
   const { actions, constants, selectedNodeId, validationIssues = [], t } = input;
+  const labels = makeAutomationLabels(t, constants);
 
   const actionNodes: Node<ActionNodeData>[] = actions.map((action, i) => {
     const nodeId = `action-${i}`;
     const actionLabel =
-      constants?.actionTypes[action.type]?.label ?? (action.type || t("nodes.selectAction"));
+      action.type ? labels.actionLabel(action.type) : t("nodes.selectAction");
     return {
       id: nodeId,
       type: "actionNode",
@@ -125,6 +132,7 @@ function buildStepNodes(
   triggerNode: Node<TriggerNodeData>,
 ): { nodes: Node[]; edges: Edge[] } {
   const { steps = [], entryStepId, constants, selectedNodeId, validationIssues = [], t } = input;
+  const labels = makeAutomationLabels(t, constants);
 
   const allNodes: Node[] = [triggerNode];
   const allEdges: Edge[] = [];
@@ -160,7 +168,7 @@ function buildStepNodes(
 
     if (step.type === "action") {
       const nodeId = `step-${step.id}`;
-      const label = constants?.actionTypes[step.action.type]?.label ?? (step.action.type || t("nodes.selectAction"));
+      const label = step.action.type ? labels.actionLabel(step.action.type) : t("nodes.selectAction");
       allNodes.push({
         id: nodeId,
         type: "actionNode",
@@ -234,7 +242,7 @@ function buildStepNodes(
     const nodeId = `step-${step.id}`;
 
     if (step.type === "action") {
-      const label = constants?.actionTypes[step.action.type]?.label ?? (step.action.type || t("nodes.selectAction"));
+      const label = step.action.type ? labels.actionLabel(step.action.type) : t("nodes.selectAction");
       allNodes.push({
         id: nodeId,
         type: "actionNode",
@@ -383,11 +391,12 @@ export function useWorkflowNodes(input: WorkflowNodesInput) {
       validationIssues = [],
       t,
     } = input;
+    const labels = makeAutomationLabels(t, constants);
 
     const triggerLabel =
-      constants?.eventTypes[eventType]?.label ?? (eventType || t("nodes.selectTrigger"));
+      eventType ? labels.eventLabel(eventType) : t("nodes.selectTrigger");
     const triggerDescription =
-      constants?.eventTypes[eventType]?.description ?? "";
+      eventType ? labels.eventDescription(eventType) : "";
 
     const triggerNode: Node<TriggerNodeData> = {
       id: "trigger",
@@ -398,6 +407,16 @@ export function useWorkflowNodes(input: WorkflowNodesInput) {
         label: triggerLabel,
         description: triggerDescription,
         validationState: getNodeValidationState("trigger", validationIssues),
+      // Active filters were invisible outside the open detail panel, so a rule
+      // scoped to two channels looked identical to an unscoped one.
+      filterCount: input.conditions
+        ? (input.conditions.channelIds?.length ?? 0) +
+          (input.conditions.roleIds?.length ?? 0) +
+          (input.conditions.userIds?.length ?? 0) +
+          (input.conditions.excludeChannelIds?.length ?? 0) +
+          (input.conditions.excludeRoleIds?.length ?? 0) +
+          (input.conditions.excludeUserIds?.length ?? 0)
+        : 0,
       },
       draggable: true,
       selected: selectedNodeId === "trigger",
@@ -427,6 +446,7 @@ export function useWorkflowNodes(input: WorkflowNodesInput) {
     input.selectedNodeId,
     input.onAddAction,
     input.validationIssues,
+    input.conditions,
     input.t,
   ]);
 
diff --git a/apps/dashboard/src/client/features/automation/workflow/useWorkflowSteps.ts b/apps/dashboard/src/client/features/automation/workflow/useWorkflowSteps.ts
index 9143659b..5b15b55d 100644
--- a/apps/dashboard/src/client/features/automation/workflow/useWorkflowSteps.ts
+++ b/apps/dashboard/src/client/features/automation/workflow/useWorkflowSteps.ts
@@ -437,6 +437,25 @@ export function useWorkflowSteps({
     setActions((prev) => prev.filter((_, i) => i !== index));
   }, []);
 
+  /**
+   * Removes a whole set of actions in one pass.
+   *
+   * React Flow delivers one `remove` change per node in a multi-select Delete.
+   * Applying them by index in a loop is wrong: every removal splices the
+   * array, so from the second onward the index refers to a different action —
+   * deleting nodes 0 and 2 removed actions 0 and 3.
+   *
+   * The canvas always shows at least one action node, so an empty result is
+   * reset to a single blank action rather than leaving nothing to click.
+   */
+  const handleActionsRemove = useCallback((indices: number[]) => {
+    const doomed = new Set(indices);
+    setActions((prev) => {
+      const kept = prev.filter((_, i) => !doomed.has(i));
+      return kept.length > 0 ? kept : [{ type: "" }];
+    });
+  }, []);
+
   const handleActionMove = useCallback((index: number, direction: "up" | "down") => {
     setActions((prev) => {
       const next = [...prev];
@@ -461,6 +480,7 @@ export function useWorkflowSteps({
     handleEdgeRemoval,
     handleActionChange,
     handleActionRemove,
+    handleActionsRemove,
     handleActionMove,
     convertToStepMode,
     convertAndSeverEdges,
diff --git a/apps/dashboard/src/client/features/logging/components/LogsTable.tsx b/apps/dashboard/src/client/features/logging/components/LogsTable.tsx
index 22bd6e9c..f850d6c1 100644
--- a/apps/dashboard/src/client/features/logging/components/LogsTable.tsx
+++ b/apps/dashboard/src/client/features/logging/components/LogsTable.tsx
@@ -19,6 +19,7 @@ import {
   SelectTrigger,
   SelectValue,
 } from "../../../shared/ui/select";
+import { useAutomationLabels } from "../../automation/lib/labels";
 
 const PAGE_SIZE = 10;
 
@@ -26,6 +27,7 @@ export function LogsTable() {
   const { t } = useTranslation("logs");
   const { guildId } = useParams({ from: "/guild/$guildId" });
   const { data: constants } = useConstants();
+  const labels = useAutomationLabels(constants);
   const [ruleFilter, setRuleFilter] = useState("");
   const [dateRange, setDateRange] = useState("7d");
   const [page, setPage] = useState(1);
@@ -131,10 +133,10 @@ export function LogsTable() {
                     </TableCell>
                     <TableCell className="text-sm font-semibold">{log.ruleName}</TableCell>
                     <TableCell className="text-sm text-text-muted">
-                      {constants?.eventTypes[log.eventType]?.label ?? log.eventType}
+                      {labels.eventLabel(log.eventType)}
                     </TableCell>
                     <TableCell className="text-sm text-text-muted">
-                      {constants?.actionTypes[log.actionType]?.label ?? log.actionType}
+                      {labels.actionLabel(log.actionType)}
                     </TableCell>
                     <TableCell className="text-center">
                       <Badge variant={log.success ? "success" : "destructive"}>
diff --git a/apps/dashboard/src/client/features/overview/components/RecentActivityFeed.tsx b/apps/dashboard/src/client/features/overview/components/RecentActivityFeed.tsx
index 84c1d316..a17d2882 100644
--- a/apps/dashboard/src/client/features/overview/components/RecentActivityFeed.tsx
+++ b/apps/dashboard/src/client/features/overview/components/RecentActivityFeed.tsx
@@ -3,6 +3,7 @@ import { useTranslation } from "react-i18next";
 import type { TFunction } from "i18next";
 import { Icon } from "../../../shared/components/Icon";
 import type { Constants } from "../../../shared/lib/schemas";
+import { useAutomationLabels } from "../../automation/lib/labels";
 
 interface ActivityItem {
   id: number;
@@ -33,6 +34,7 @@ function timeAgo(dateStr: string, t: TFunction): string {
 
 export function RecentActivityFeed({ data, guildId, constants }: RecentActivityFeedProps) {
   const { t } = useTranslation("overview");
+  const labels = useAutomationLabels(constants);
   return (
     <div className="rounded-lg bg-surface-low p-6 glass-edge">
       <div className="mb-5 flex items-center justify-between">
@@ -71,9 +73,9 @@ export function RecentActivityFeed({ data, guildId, constants }: RecentActivityF
                   {item.ruleName}
                 </p>
                 <p className="truncate text-xs text-text-muted">
-                  {constants?.eventTypes[item.eventType]?.label ?? item.eventType}
+                  {labels.eventLabel(item.eventType)}
                   {" → "}
-                  {constants?.actionTypes[item.actionType]?.label ?? item.actionType}
+                  {labels.actionLabel(item.actionType)}
                 </p>
               </div>
               <span className="shrink-0 font-mono text-[11px] text-text-tertiary">
diff --git a/apps/dashboard/src/client/routes/guild/$guildId/rules.tsx b/apps/dashboard/src/client/routes/guild/$guildId/rules.tsx
index de24c2b7..dfb93312 100644
--- a/apps/dashboard/src/client/routes/guild/$guildId/rules.tsx
+++ b/apps/dashboard/src/client/routes/guild/$guildId/rules.tsx
@@ -1,4 +1,4 @@
-import { useState, useMemo } from "react";
+import { useState, useMemo, useEffect } from "react";
 import { useParams } from "@tanstack/react-router";
 import { useTranslation } from "react-i18next";
 import type { TFunction } from "i18next";
@@ -30,6 +30,7 @@ import {
   SelectValue,
 } from "../../../shared/ui/select";
 import type { ActionRule } from "../../../shared/lib/schemas";
+import { useAutomationLabels } from "../../../features/automation/lib/labels";
 
 // ── Preset templates ──────────────────────────────────────────────────
 
@@ -160,6 +161,7 @@ export function RulesPage() {
   const { guildId } = useParams({ from: "/guild/$guildId" });
   const { data: rules = [], isLoading } = useRules(guildId);
   const { data: constants } = useConstants();
+  const labels = useAutomationLabels(constants);
   const { data: analytics } = useAnalytics(guildId, 7);
   const createRule = useCreateRule(guildId);
   const updateRule = useUpdateRule(guildId);
@@ -172,6 +174,9 @@ export function RulesPage() {
   const [deleteTarget, setDeleteTarget] = useState<ActionRule | null>(null);
   const [selectedRuleIds, setSelectedRuleIds] = useState<Set<number>>(new Set());
   const [bulkDeleteConfirm, setBulkDeleteConfirm] = useState(false);
+  // The template gallery used to render only while `rules.length === 0`, so a
+  // user with one existing rule could never see the presets again.
+  const [showTemplates, setShowTemplates] = useState(false);
 
   // Filters
   const [search, setSearch] = useState("");
@@ -202,11 +207,23 @@ export function RulesPage() {
     return sortRules(result, sortBy);
   }, [rules, search, eventFilter, statusFilter, sortBy]);
 
-  // Unique event types used across rules (for filter dropdown)
+  // Unique event types used across rules, ordered by their translated label
+  // rather than by raw key so the dropdown reads alphabetically to the user.
   const usedEventTypes = useMemo(() => {
     const set = new Set(rules.map((r) => r.eventType));
-    return Array.from(set).sort();
-  }, [rules]);
+    return Array.from(set).sort((a, b) =>
+      labels.eventLabel(a).localeCompare(labels.eventLabel(b)),
+    );
+  }, [rules, constants]);
+
+  // Deleting the last rule of a type removes its option, but the filter kept
+  // its now-invisible value — leaving a control with no readable label and a
+  // permanently empty list.
+  useEffect(() => {
+    if (eventFilter !== "all" && !usedEventTypes.includes(eventFilter)) {
+      setEventFilter("all");
+    }
+  }, [eventFilter, usedEventTypes]);
 
   if (isLoading) return <PageSkeleton tabs={false} content="cards" />;
 
@@ -341,6 +358,7 @@ export function RulesPage() {
   };
 
   const handleUseTemplate = (template: RuleTemplate) => {
+    setShowTemplates(false);
     setEditingRule(undefined);
     setEditorDraft(template.buildDraft(t));
     setShowEditor(true);
@@ -366,6 +384,11 @@ export function RulesPage() {
         subtitle={t("subtitle")}
         actions={
           <div className="flex items-center gap-3">
+            {!showEditor && rules.length > 0 && (
+              <Button variant="ghost" onClick={() => setShowTemplates((v) => !v)}>
+                <Icon name="auto_awesome" /> {t("templates.browse")}
+              </Button>
+            )}
             {!showEditor && (
               <Button onClick={() => setShowEditor(true)}>
                 <Icon name="add" /> {t("createRule")}
@@ -425,7 +448,7 @@ export function RulesPage() {
                 <SelectItem value="all">{t("filter.allEvents")}</SelectItem>
                 {usedEventTypes.map((et) => (
                   <SelectItem key={et} value={et}>
-                    {constants?.eventTypes[et]?.label ?? et}
+                    {labels.eventLabel(et)}
                   </SelectItem>
                 ))}
               </SelectContent>
@@ -517,7 +540,7 @@ export function RulesPage() {
 
       {showEditor ? (
         <WorkflowEditor rule={editingRule} draft={editorDraft} onClose={handleCloseEditor} />
-      ) : rules.length === 0 ? (
+      ) : rules.length === 0 || showTemplates ? (
         /* ── Template gallery (empty state) ── */
         <div className="rounded-lg bg-surface-container p-8 glass-edge">
           <div className="mb-6 text-center">
diff --git a/apps/dashboard/src/client/shared/hooks/useMembers.ts b/apps/dashboard/src/client/shared/hooks/useMembers.ts
new file mode 100644
index 00000000..bb9708f6
--- /dev/null
+++ b/apps/dashboard/src/client/shared/hooks/useMembers.ts
@@ -0,0 +1,45 @@
+import { useQuery } from "@tanstack/react-query";
+import { apiFetch } from "../lib/client";
+import { GuildMemberListSchema, type GuildMember } from "../lib/schemas";
+
+/**
+ * Search a guild's members by name.
+ *
+ * Disabled until there is something to search for: the endpoint fans out to
+ * the Discord API on our bot token, so it must not fire on an empty box.
+ * Callers should debounce the query they pass in.
+ */
+export function useMemberSearch(guildId: string, query: string) {
+  const trimmed = query.trim();
+  return useQuery<GuildMember[]>({
+    queryKey: ["guilds", guildId, "members", "search", trimmed],
+    queryFn: async () => {
+      const data = await apiFetch<unknown>(
+        `/api/guilds/${guildId}/members?q=${encodeURIComponent(trimmed)}`,
+      );
+      return GuildMemberListSchema.parse(data);
+    },
+    staleTime: 2 * 60 * 1000,
+    enabled: trimmed.length > 0,
+  });
+}
+
+/**
+ * Resolve saved member ids to names, so a stored filter renders as "Ada"
+ * rather than "123456789012345678".
+ */
+export function useMembersByIds(guildId: string, ids: string[]) {
+  // Sorted and joined so the same set in a different order is one cache entry.
+  const key = [...new Set(ids)].sort().join(",");
+  return useQuery<GuildMember[]>({
+    queryKey: ["guilds", guildId, "members", "byIds", key],
+    queryFn: async () => {
+      const data = await apiFetch<unknown>(
+        `/api/guilds/${guildId}/members?ids=${encodeURIComponent(key)}`,
+      );
+      return GuildMemberListSchema.parse(data);
+    },
+    staleTime: 5 * 60 * 1000,
+    enabled: key.length > 0,
+  });
+}
diff --git a/apps/dashboard/src/client/shared/lib/channelTypes.ts b/apps/dashboard/src/client/shared/lib/channelTypes.ts
new file mode 100644
index 00000000..6b47b4da
--- /dev/null
+++ b/apps/dashboard/src/client/shared/lib/channelTypes.ts
@@ -0,0 +1,84 @@
+/**
+ * Discord channel-type numbers and the one definition of "a channel a message
+ * or a filter can target".
+ *
+ * Three components previously each hardcoded `c.type === 0 || c.type === 2`,
+ * which silently excluded announcement, stage, forum and media channels
+ * everywhere: a rule could not be scoped to an announcement channel, and a
+ * Send Message action could not target one. Import from here instead.
+ *
+ * Values mirror Discord's ChannelType enum. We don't import discord.js into
+ * the browser bundle for six integers.
+ */
+export const CHANNEL_TYPE = {
+  GuildText: 0,
+  GuildVoice: 2,
+  GuildCategory: 4,
+  GuildAnnouncement: 5,
+  AnnouncementThread: 10,
+  PublicThread: 11,
+  PrivateThread: 12,
+  GuildStageVoice: 13,
+  GuildForum: 15,
+  GuildMedia: 16,
+} as const;
+
+/**
+ * Channels that can hold messages, and so can be picked as a Send Message /
+ * Log to Channel target or as a trigger filter.
+ *
+ * Threads are excluded deliberately: they are transient, there can be
+ * thousands, and a filter should name the parent (which
+ * `EventContext.parentChannelId` now carries) rather than one thread.
+ * Categories are excluded because they hold no messages of their own.
+ */
+const MESSAGEABLE: ReadonlySet<number> = new Set([
+  CHANNEL_TYPE.GuildText,
+  CHANNEL_TYPE.GuildVoice,
+  CHANNEL_TYPE.GuildAnnouncement,
+  CHANNEL_TYPE.GuildStageVoice,
+  CHANNEL_TYPE.GuildForum,
+  CHANNEL_TYPE.GuildMedia,
+]);
+
+export function isMessageableChannel(type: number): boolean {
+  return MESSAGEABLE.has(type);
+}
+
+/** Icon name (see shared/components/Icon) for a channel type. */
+export function channelIconName(type: number): string {
+  switch (type) {
+    case CHANNEL_TYPE.GuildVoice:
+      return "volume_up";
+    case CHANNEL_TYPE.GuildStageVoice:
+      return "podcasts";
+    case CHANNEL_TYPE.GuildAnnouncement:
+      return "campaign";
+    case CHANNEL_TYPE.GuildForum:
+    case CHANNEL_TYPE.GuildMedia:
+      return "forum";
+    case CHANNEL_TYPE.GuildCategory:
+      return "folder";
+    default:
+      return "hash";
+  }
+}
+
+/** Text prefix used where an icon component cannot be rendered. */
+export function channelLabelPrefix(type: number): string {
+  switch (type) {
+    case CHANNEL_TYPE.GuildVoice:
+      return "🔊";
+    case CHANNEL_TYPE.GuildStageVoice:
+      return "🎙️";
+    case CHANNEL_TYPE.GuildAnnouncement:
+      return "📢";
+    case CHANNEL_TYPE.GuildForum:
+    case CHANNEL_TYPE.GuildMedia:
+      return "💬";
+    case CHANNEL_TYPE.GuildCategory:
+      return "📁";
+    default:
+      return "#";
+  }
+}
diff --git a/apps/dashboard/src/client/shared/lib/schemas.ts b/apps/dashboard/src/client/shared/lib/schemas.ts
index 18764a56..cdd7fb1a 100644
--- a/apps/dashboard/src/client/shared/lib/schemas.ts
+++ b/apps/dashboard/src/client/shared/lib/schemas.ts
@@ -40,6 +40,17 @@ export type Role = z.infer<typeof RoleSchema>;
 
 export const RoleListSchema = z.array(RoleSchema);
 
+/** A guild member, as returned by /api/guilds/:guildId/members. */
+export const GuildMemberSchema = z.object({
+  id: z.string(),
+  username: z.string(),
+  displayName: z.string(),
+  avatar: z.string().nullable(),
+});
+export type GuildMember = z.infer<typeof GuildMemberSchema>;
+
+export const GuildMemberListSchema = z.array(GuildMemberSchema);
+
 // --- Action Constants ---
 export const EventTypeInfoSchema = z.object({
   label: z.string(),
@@ -54,7 +65,7 @@ export const ActionTypeInfoSchema = z.object({
 export const ActionFieldDescriptorSchema = z.object({
   key: z.string(),
   label: z.string(),
-  type: z.enum(["channel", "role", "text", "textarea", "color", "select"]),
+  type: z.enum(["channel", "role", "text", "textarea", "color", "select", "json"]),
   placeholder: z.string().optional(),
   required: z.boolean().optional(),
   options: z
@@ -74,6 +85,15 @@ export const ConstantsSchema = z.object({
   ),
   eventTypeVariables: z.record(z.string(), z.array(z.string())),
   templateVariables: z.record(z.string(), z.string()),
+  /**
+   * Which filter subjects each event type can evaluate. Trigger filters fail
+   * closed in the bot, so the editor uses this to avoid offering a filter that
+   * would silently stop the rule from firing.
+   */
+  eventConditionSupport: z.record(
+    z.string(),
+    z.array(z.enum(["channel", "role", "user"])),
+  ),
 });
 export type Constants = z.infer<typeof ConstantsSchema>;
 
diff --git a/apps/dashboard/src/client/shared/ui/discord-multi-select.tsx b/apps/dashboard/src/client/shared/ui/discord-multi-select.tsx
index f9f40868..1c72d183 100644
--- a/apps/dashboard/src/client/shared/ui/discord-multi-select.tsx
+++ b/apps/dashboard/src/client/shared/ui/discord-multi-select.tsx
@@ -1,10 +1,12 @@
-import { useState, useRef, useEffect, useMemo } from "react";
+import { useState, useRef, useEffect, useMemo, useId } from "react";
+import { useTranslation } from "react-i18next";
 import { useChannels } from "../hooks/useChannels";
 import { useRoles } from "../hooks/useRoles";
 import { Popover, PopoverContent, PopoverTrigger } from "./popover";
 import { SelectSkeleton } from "./skeletons";
 import { Label } from "./label";
 import { cn } from "../lib/utils";
+import { CHANNEL_TYPE, channelLabelPrefix, isMessageableChannel } from "../lib/channelTypes";
 
 export type DiscordMultiSelectType = "text" | "voice" | "any" | "role";
 
@@ -18,7 +20,7 @@ export interface DiscordMultiSelectProps {
 }
 
 function channelLabel(name: string, channelType: number): string {
-  return channelType === 2 ? `🔊 ${name}` : `# ${name}`;
+  return `${channelLabelPrefix(channelType)} ${name}`;
 }
 
 export function DiscordMultiSelect({
@@ -29,9 +31,14 @@ export function DiscordMultiSelect({
   placeholder,
   label,
 }: DiscordMultiSelectProps) {
+  const { t } = useTranslation("common");
   const [open, setOpen] = useState(false);
   const [search, setSearch] = useState("");
   const searchRef = useRef<HTMLInputElement>(null);
+  // The rendered <Label> was never associated with the trigger, so the four
+  // include/exclude comboboxes in the trigger-filter panel had no accessible
+  // name and were indistinguishable from one another.
+  const triggerId = useId();
 
   const isRole = type === "role";
   const {
@@ -54,9 +61,12 @@ export function DiscordMultiSelect({
         ? (roles ?? []).map((r) => ({ id: r.id, name: `● ${r.name}` }))
         : (channels ?? [])
             .filter((c) => {
-              if (type === "text") return c.type === 0;
-              if (type === "voice") return c.type === 2;
-              return c.type === 0 || c.type === 2;
+              if (type === "text") return c.type === CHANNEL_TYPE.GuildText;
+              if (type === "voice") return c.type === CHANNEL_TYPE.GuildVoice;
+              // "any" means any channel a message or a filter can target —
+              // including announcement, stage, forum and media, which a
+              // hardcoded `type === 0 || type === 2` silently excluded.
+              return isMessageableChannel(c.type);
             })
             .map((c) => ({ id: c.id, name: channelLabel(c.name, c.type) })),
     [isRole, roles, channels, type],
@@ -105,7 +115,11 @@ export function DiscordMultiSelect({
 
   return (
     <div className="space-y-2">
-      {label && <Label className="text-xs">{label}</Label>}
+      {label && (
+        <Label htmlFor={triggerId} className="text-xs">
+          {label}
+        </Label>
+      )}
 
       {isLoading ? (
         <SelectSkeleton />
@@ -122,6 +136,7 @@ export function DiscordMultiSelect({
           <PopoverTrigger asChild>
             <button
               type="button"
+              id={triggerId}
               className={cn(
                 "flex h-9 w-full items-center justify-between rounded-sm bg-surface-lowest px-3 py-2 text-sm focus:outline-none focus:ring-1 focus:ring-ring",
                 chips.length > 0 ? "text-text" : "text-outline",
@@ -129,7 +144,7 @@ export function DiscordMultiSelect({
             >
               <span className="truncate">
                 {chips.length > 0
-                  ? `${chips.length} selected`
+                  ? t("form.selectedCount", { count: chips.length })
                   : placeholder ?? defaultPlaceholder}
               </span>
               <svg
@@ -160,7 +175,7 @@ export function DiscordMultiSelect({
                 ref={searchRef}
                 value={search}
                 onChange={(e) => setSearch(e.target.value)}
-                placeholder="Search..."
+                placeholder={t("form.search")}
                 className="w-full rounded-sm bg-surface-lowest px-2.5 py-1.5 text-sm text-text placeholder:text-outline focus:outline-none"
               />
             </div>
@@ -240,7 +255,7 @@ export function DiscordMultiSelect({
               <span className="max-w-32 truncate">{chip.label}</span>
               <button
                 type="button"
-                aria-label={`Remove ${chip.label}`}
+                aria-label={t("form.removeItem", { label: chip.label })}
                 onClick={() => remove(chip.id)}
                 className="rounded-xs p-0.5 transition-colors hover:bg-accent/20 hover:text-text"
               >
diff --git a/apps/dashboard/src/client/shared/ui/member-multi-select.tsx b/apps/dashboard/src/client/shared/ui/member-multi-select.tsx
new file mode 100644
index 00000000..25b74152
--- /dev/null
+++ b/apps/dashboard/src/client/shared/ui/member-multi-select.tsx
@@ -0,0 +1,144 @@
+import { useState, useMemo, useId, useEffect } from "react";
+import { useTranslation } from "react-i18next";
+import { Popover, PopoverContent, PopoverTrigger } from "./popover";
+import { Label } from "./label";
+import { Badge } from "./badge";
+import { Icon } from "../components/Icon";
+import { useMemberSearch, useMembersByIds } from "../hooks/useMembers";
+
+interface MemberMultiSelectProps {
+  guildId: string;
+  selectedIds: string[];
+  onChange: (ids: string[]) => void;
+  label: string;
+  placeholder: string;
+  chipColor?: "secondary" | "destructive";
+}
+
+/** Debounces a value so typing does not fire one request per keystroke. */
+function useDebounced<T>(value: T, ms: number): T {
+  const [debounced, setDebounced] = useState(value);
+  useEffect(() => {
+    const id = setTimeout(() => setDebounced(value), ms);
+    return () => clearTimeout(id);
+  }, [value, ms]);
+  return debounced;
+}
+
+/**
+ * Member picker for trigger filters.
+ *
+ * Replaces a bare text box that demanded a raw 17-20 digit snowflake and
+ * rendered saved members as those same digits — there was no members endpoint
+ * in the dashboard at all until now, which is why it worked that way.
+ */
+export function MemberMultiSelect({
+  guildId,
+  selectedIds,
+  onChange,
+  label,
+  placeholder,
+  chipColor = "secondary",
+}: MemberMultiSelectProps) {
+  const { t } = useTranslation(["common", "rules"]);
+  const [open, setOpen] = useState(false);
+  const [search, setSearch] = useState("");
+  const debouncedSearch = useDebounced(search, 250);
+  const triggerId = useId();
+
+  const { data: results = [], isLoading } = useMemberSearch(guildId, debouncedSearch);
+  const { data: selected = [] } = useMembersByIds(guildId, selectedIds);
+
+  const selectedSet = useMemo(() => new Set(selectedIds), [selectedIds]);
+  const options = results.filter((m) => !selectedSet.has(m.id));
+
+  // A member who has since left the guild will not resolve; show the raw id
+  // rather than dropping them silently, so the filter stays editable.
+  const chips = selectedIds.map((id) => {
+    const found = selected.find((m) => m.id === id);
+    return { id, label: found?.displayName ?? id, avatar: found?.avatar ?? null };
+  });
+
+  return (
+    <div className="space-y-1.5">
+      <Label htmlFor={triggerId} className="text-xs">
+        {label}
+      </Label>
+      <Popover open={open} onOpenChange={setOpen}>
+        <PopoverTrigger asChild>
+          <button
+            id={triggerId}
+            type="button"
+            className="flex h-9 w-full items-center justify-between rounded-sm bg-surface-lowest px-3 py-2 text-sm text-outline focus:outline-none focus:ring-1 focus:ring-ring"
+          >
+            <span className="truncate">
+              {chips.length > 0
+                ? t("common:form.selectedCount", { count: chips.length })
+                : placeholder}
+            </span>
+            <Icon name="expand_more" size={16} />
+          </button>
+        </PopoverTrigger>
+        <PopoverContent align="start" className="w-72 p-2">
+          <input
+            type="text"
+            value={search}
+            onChange={(e) => setSearch(e.target.value)}
+            placeholder={t("common:form.search")}
+            aria-label={t("common:form.search")}
+            className="mb-2 w-full rounded-sm bg-surface-lowest px-2.5 py-1.5 text-sm text-text placeholder:text-outline focus:outline-none"
+          />
+          <div className="max-h-56 overflow-y-auto" role="listbox" aria-label={label}>
+            {isLoading && (
+              <p className="px-2 py-3 text-xs text-text-muted">{t("common:form.loading")}</p>
+            )}
+            {!isLoading && debouncedSearch.trim() === "" && (
+              <p className="px-2 py-3 text-xs text-text-muted">
+                {t("rules:conditions.memberSearchHint")}
+              </p>
+            )}
+            {!isLoading && debouncedSearch.trim() !== "" && options.length === 0 && (
+              <p className="px-2 py-3 text-xs text-text-muted">{t("common:form.noResults")}</p>
+            )}
+            {options.map((member) => (
+              <button
+                key={member.id}
+                type="button"
+                role="option"
+                aria-selected={false}
+                onClick={() => {
+                  onChange([...selectedIds, member.id]);
+                  setSearch("");
+                }}
+                className="flex w-full items-center gap-2 rounded px-2 py-1.5 text-start text-sm hover:bg-surface-high focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+              >
+                <span className="truncate">{member.displayName}</span>
+                <span className="ms-auto truncate text-[11px] text-text-muted">
+                  @{member.username}
+                </span>
+              </button>
+            ))}
+          </div>
+        </PopoverContent>
+      </Popover>
+
+      {chips.length > 0 && (
+        <div className="flex flex-wrap gap-1.5">
+          {chips.map((chip) => (
+            <Badge key={chip.id} variant={chipColor} className="gap-1 pe-1 text-[11px]">
+              {chip.label}
+              <button
+                type="button"
+                aria-label={t("common:form.removeItem", { label: chip.label })}
+                onClick={() => onChange(selectedIds.filter((id) => id !== chip.id))}
+                className="ms-0.5 rounded-full p-1 hover:bg-white/10 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+              >
+                <Icon name="close" size={10} />
+              </button>
+            </Badge>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/apps/dashboard/src/server/features/actions/routes.ts b/apps/dashboard/src/server/features/actions/routes.ts
index 4d711236..0105ea68 100644
--- a/apps/dashboard/src/server/features/actions/routes.ts
+++ b/apps/dashboard/src/server/features/actions/routes.ts
@@ -26,6 +26,8 @@ import {
   ACTION_TYPE_FIELDS,
   EVENT_TYPE_VARIABLES,
   TEMPLATE_VARIABLES,
+  EVENT_CONDITION_SUPPORT,
+  isSafeRuleName,
 } from "@fluxcore/systems/actions/constants";
 import type { ActionEventType, ActionType, RuleStep } from "@fluxcore/systems/actions/types";
 import { channelExistsInGuild } from "../../shared/discordApi.js";
@@ -47,6 +49,90 @@ interface RuleRequestBody {
   enabled?: boolean;
 }
 
+/** Walks a dotted descriptor key (e.g. `webhook.url`) into an action config. */
+function getNestedValue(obj: Record<string, unknown>, path: string): unknown {
+  let current: unknown = obj;
+  for (const part of path.split(".")) {
+    if (current === null || current === undefined || typeof current !== "object") {
+      return undefined;
+    }
+    current = (current as Record<string, unknown>)[part];
+  }
+  return current;
+}
+
+/**
+ * Checks one action against ACTION_TYPE_FIELDS — the same descriptor list the
+ * dashboard renders its form from, so the client and the API cannot drift.
+ *
+ * An action missing a required field can never execute: the bot has no channel
+ * to post to, no role to add. Letting it through produces a rule that looks
+ * healthy in the list and silently never fires. The client blocks this too, but
+ * the client is not the gate — `rules.tsx` re-POSTs stored action lists on the
+ * Undo-delete and Duplicate paths without revalidating, and the API is reachable
+ * by any script.
+ *
+ * Returns an error string, or null when the action is valid.
+ */
+function validateActionConfig(action: { type: string; [key: string]: unknown }): string | null {
+  if (!validActionTypes.has(action.type)) {
+    return `Invalid action type: ${action.type}`;
+  }
+
+  for (const field of ACTION_TYPE_FIELDS[action.type as ActionType] ?? []) {
+    if (!field.required) continue;
+    const value = getNestedValue(action, field.key);
+    if (
+      value === undefined ||
+      value === null ||
+      (typeof value === "string" && value.trim() === "")
+    ) {
+      return `${action.type}: ${field.label} is required`;
+    }
+  }
+
+  if (action.type === "sendWebhook") {
+    const webhook = action.webhook as { url?: string } | undefined;
+    try {
+      const url = new URL(webhook!.url!);
+      if (url.protocol !== "https:") {
+        return "Webhook URL must use HTTPS";
+      }
+    } catch {
+      return "Invalid webhook URL";
+    }
+  }
+
+  return null;
+}
+
+const CONDITION_KEYS = new Set([
+  "channelIds", "roleIds", "userIds",
+  "excludeChannelIds", "excludeRoleIds", "excludeUserIds",
+]);
+const SNOWFLAKE = /^\d{17,20}$/;
+
+/**
+ * Trigger conditions were stored verbatim — any key, any value. A malformed id
+ * can never match anything, so the rule silently never fires, and unknown keys
+ * accumulate in the database forever.
+ */
+function validateConditions(conditions: RuleRequestBody["conditions"]): string | null {
+  if (conditions === undefined) return null;
+  if (typeof conditions !== "object" || conditions === null || Array.isArray(conditions)) {
+    return "Conditions must be an object";
+  }
+  for (const [key, value] of Object.entries(conditions)) {
+    if (!CONDITION_KEYS.has(key)) {
+      return `Unknown condition: ${key}`;
+    }
+    if (!Array.isArray(value) || value.some((v) => typeof v !== "string" || !SNOWFLAKE.test(v))) {
+      return `${key} must be a list of Discord IDs (17-20 digits)`;
+    }
+  }
+  return null;
+}
+
 /**
  * Validates rule request body fields shared between create and update.
  * Returns an error string if validation fails, or null if valid.
@@ -56,15 +142,21 @@ function validateRuleBody(
   options: { requireName: boolean; requireActions: boolean },
 ): string | null {
   if (options.requireName) {
-    if (!body.name || typeof body.name !== "string" || body.name.length > 50) {
+    if (!body.name || typeof body.name !== "string") {
       return "Name is required (max 50 chars)";
     }
+    if (!isSafeRuleName(body.name)) {
+      return "Name must be 1-50 characters and cannot contain markdown, mention syntax, or invisible characters";
+    }
   } else if (body.name !== undefined) {
-    if (typeof body.name !== "string" || body.name.length > 50) {
-      return "Name must be a string (max 50 chars)";
+    if (typeof body.name !== "string" || !isSafeRuleName(body.name)) {
+      return "Name must be 1-50 characters and cannot contain markdown, mention syntax, or invisible characters";
     }
   }
 
+  const conditionsError = validateConditions(body.conditions);
+  if (conditionsError) return conditionsError;
+
   if (options.requireActions) {
     if (!body.eventType || !validEventTypes.has(body.eventType)) {
       return "Invalid event type";
@@ -83,23 +175,8 @@ function validateRuleBody(
       return `Max ${MAX_ACTIONS_PER_RULE} actions per rule`;
     }
     for (const action of body.actions) {
-      if (!validActionTypes.has(action.type)) {
-        return `Invalid action type: ${action.type}`;
-      }
-      if (action.type === "sendWebhook") {
-        const webhook = action.webhook as { url?: string } | undefined;
-        if (!webhook?.url) {
-          return "sendWebhook requires a webhook URL";
-        }
-        try {
-          const url = new URL(webhook.url);
-          if (url.protocol !== "https:") {
-            return "Webhook URL must use HTTPS";
-          }
-        } catch {
-          return "Invalid webhook URL";
-        }
-      }
+      const actionError = validateActionConfig(action);
+      if (actionError) return actionError;
     }
   }
 
@@ -111,6 +188,18 @@ function validateRuleBody(
     if (conditionCount > 3) {
       return "Max 3 condition steps per rule";
     }
+    // The bot runs the step graph in preference to the flat action list
+    // (executor.ts), so validating only `actions` would leave the path that
+    // actually executes unchecked.
+    for (const step of body.steps) {
+      if (step.type !== "action") continue;
+      const action = step.action as { type: string; [key: string]: unknown } | undefined;
+      if (!action || typeof action.type !== "string") {
+        return `Step ${step.id} is missing an action`;
+      }
+      const actionError = validateActionConfig(action);
+      if (actionError) return actionError;
+    }
   }
 
   return null;
@@ -173,6 +262,7 @@ export function registerActionRoutes(app: FastifyInstance): void {
               actionTypeFields: { type: "object", additionalProperties: true },
               eventTypeVariables: { type: "object", additionalProperties: true },
               templateVariables: { type: "object", additionalProperties: true },
+              eventConditionSupport: { type: "object", additionalProperties: true },
             },
           },
         },
@@ -186,6 +276,9 @@ export function registerActionRoutes(app: FastifyInstance): void {
         actionTypeFields: ACTION_TYPE_FIELDS,
         eventTypeVariables: EVENT_TYPE_VARIABLES,
         templateVariables: TEMPLATE_VARIABLES,
+        // Trigger filters fail closed, so the editor only offers the filters a
+        // given trigger can actually satisfy.
+        eventConditionSupport: EVENT_CONDITION_SUPPORT,
       });
     },
   );
@@ -246,7 +339,9 @@ export function registerActionRoutes(app: FastifyInstance): void {
         return;
       }
 
-      const rule = await createRule({
+      let rule;
+      try {
+        rule = await createRule({
         guildId,
         name: body.name!,
         eventType: body.eventType as ActionEventType,
@@ -261,7 +356,17 @@ export function registerActionRoutes(app: FastifyInstance): void {
         priority: body.priority ?? 0,
         enabled: body.enabled ?? true,
         createdBy: request.session!.userId,
-      });
+        });
+      } catch (err) {
+        // Prisma's unique-constraint violation surfaced unhandled as a 500
+        // with a generic client message that told the user nothing they could
+        // act on.
+        if (typeof err === "object" && err !== null && "code" in err && err.code === "P2002") {
+          reply.code(409).send({ error: "A rule with that name already exists" });
+          return;
+        }
+        throw err;
+      }
 
       await notifyCacheInvalidation(guildId);
       reply.code(201).send(rule);
diff --git a/apps/dashboard/src/server/features/discord/routes.ts b/apps/dashboard/src/server/features/discord/routes.ts
index 38c10817..23ff706a 100644
--- a/apps/dashboard/src/server/features/discord/routes.ts
+++ b/apps/dashboard/src/server/features/discord/routes.ts
@@ -3,6 +3,8 @@ import { requireAuth, requireGuildAdmin } from "../../shared/middleware.js";
 import {
   getGuildChannels,
   getGuildRoles,
+  searchGuildMembers,
+  getGuildMembersByIds,
   invalidateGuildCache,
 } from "../../shared/discordApi.js";
 import { forceRefreshSessionGuilds } from "../../shared/session.js";
@@ -15,7 +17,64 @@ const GuildText = 0;
 const GuildVoice = 2;
 const GuildCategory = 4;
 
+const MEMBER_RESULT_SHAPE = {
+  type: "array",
+  items: {
+    type: "object",
+    properties: {
+      id: { type: "string" },
+      username: { type: "string" },
+      displayName: { type: "string" },
+      avatar: { type: "string", nullable: true },
+    },
+  },
+} as const;
+
 export function registerDiscordRoutes(app: FastifyInstance): void {
+  /**
+   * Member lookup for trigger filters.
+   *
+   * `?q=` searches by name prefix; `?ids=` resolves saved ids back to names so
+   * a stored filter renders as "Ada" rather than "123456789012345678".
+   * Rate-limited like the other Discord passthroughs — it fans out to the
+   * Discord API and is reachable per keystroke.
+   */
+  app.get(
+    "/api/guilds/:guildId/members",
+    {
+      preHandler: [requireAuth, requireGuildAdmin],
+      config: rateLimits.discordRead,
+      schema: withDocs(
+        {
+          params: { type: "object", properties: { guildId: { type: "string" } }, required: ["guildId"] },
+          querystring: {
+            type: "object",
+            properties: { q: { type: "string" }, ids: { type: "string" } },
+          },
+        },
+        { tag: "Discord", response: { 200: MEMBER_RESULT_SHAPE } },
+      ),
+    },
+    async (request, reply) => {
+      const { guildId } = request.params as { guildId: string };
+      const { q, ids } = request.query as { q?: string; ids?: string };
+      try {
+        if (ids) {
+          const list = ids.split(",").map((s) => s.trim()).filter(Boolean);
+          reply.send(await getGuildMembersByIds(guildId, list));
+          return;
+        }
+        reply.send(await searchGuildMembers(guildId, q ?? ""));
+      } catch (err) {
+        logger.error(
+          `Failed to look up members for guild ${guildId}`,
+          err instanceof Error ? err : new Error(String(err)),
+        );
+        reply.send([]);
+      }
+    },
+  );
+
   app.get(
     "/api/guilds/:guildId/channels",
     {
diff --git a/apps/dashboard/src/server/shared/discordApi.ts b/apps/dashboard/src/server/shared/discordApi.ts
index 3d8dadc5..51128e92 100644
--- a/apps/dashboard/src/server/shared/discordApi.ts
+++ b/apps/dashboard/src/server/shared/discordApi.ts
@@ -71,6 +71,18 @@ export interface DiscordRole {
 export interface DiscordGuildMember {
   /** IDs of the roles assigned to the member. */
   roles: string[];
+  /** Guild-specific nickname, when set. */
+  nick?: string | null;
+  /**
+   * The underlying user. Present on the real payload; typed optional because
+   * this shape is also used for live authorization, where only `roles` is read.
+   */
+  user?: {
+    id: string;
+    username: string;
+    global_name?: string | null;
+    avatar?: string | null;
+  };
 }
 
 /**
@@ -177,6 +189,81 @@ export async function getGuildRoles(guildId: string): Promise<DiscordRole[]> {
   return result;
 }
 
+export interface DiscordGuildMemberSummary {
+  id: string;
+  username: string;
+  displayName: string;
+  avatar: string | null;
+}
+
+/**
+ * Search a guild's members by name prefix, via the bot token.
+ *
+ * Exists so trigger filters can offer a real member picker: before this there
+ * was no members endpoint anywhere in the dashboard, so the only way to filter
+ * by member was to paste a raw 17-20 digit snowflake, and saved filters
+ * rendered as bare digits.
+ *
+ * Uses Discord's `members/search`, which needs the GUILD_MEMBERS intent (the
+ * bot already declares it). Results are cached per (guild, query) on the same
+ * short TTL as the channel and role lookups.
+ */
+export async function searchGuildMembers(
+  guildId: string,
+  query: string,
+  limit = 25,
+): Promise<DiscordGuildMemberSummary[]> {
+  const trimmed = query.trim().slice(0, 100);
+  if (trimmed.length === 0) return [];
+
+  const cacheKey = `members:${guildId}:${trimmed.toLowerCase()}:${limit}`;
+  const cached = getCached<DiscordGuildMemberSummary[]>(cacheKey);
+  if (cached !== undefined) return cached;
+
+  const raw = await botFetch<
+    Array<{
+      nick?: string | null;
+      user: { id: string; username: string; global_name?: string | null; avatar: string | null };
+    }>
+  >(
+    `/guilds/${guildId}/members/search?query=${encodeURIComponent(trimmed)}&limit=${limit}`,
+  );
+
+  const members: DiscordGuildMemberSummary[] = (raw ?? []).map((m) => ({
+    id: m.user.id,
+    username: m.user.username,
+    displayName: m.nick ?? m.user.global_name ?? m.user.username,
+    avatar: m.user.avatar,
+  }));
+  setCache(cacheKey, members);
+  return members;
+}
+
+/**
+ * Resolve specific member ids to names, so a saved filter can render as
+ * "Ada" rather than "123456789012345678". Missing members (left the guild,
+ * deleted account) are simply absent from the result.
+ */
+export async function getGuildMembersByIds(
+  guildId: string,
+  ids: string[],
+): Promise<DiscordGuildMemberSummary[]> {
+  const unique = Array.from(new Set(ids)).slice(0, 50);
+  const results = await Promise.all(
+    unique.map(async (id) => {
+      const member = await getGuildMember(guildId, id);
+      if (!member?.user) return null;
+      return {
+        id: member.user.id,
+        username: member.user.username,
+        displayName: member.nick ?? member.user.global_name ?? member.user.username,
+        avatar: member.user.avatar ?? null,
+      } satisfies DiscordGuildMemberSummary;
+    }),
+  );
+  return results.filter((m): m is DiscordGuildMemberSummary => m !== null);
+}
+
 /**
  * Check if a specific channel exists in a guild.
  * Reuses the channels cache, so no extra API call if channels were recently fetched.
diff --git a/apps/dashboard/src/server/shared/rateLimit.ts b/apps/dashboard/src/server/shared/rateLimit.ts
index 5d9582ea..b0a2c27f 100644
--- a/apps/dashboard/src/server/shared/rateLimit.ts
+++ b/apps/dashboard/src/server/shared/rateLimit.ts
@@ -105,6 +105,12 @@ export const rateLimits = {
   external: { rateLimit: { max: 5, timeWindow: "1 minute" } },
   /** Resource creation. */
   create: { rateLimit: { max: 10, timeWindow: "1 minute" } },
+  /**
+   * Read-only passthroughs to the Discord API that a user can trigger while
+   * typing (member search). Generous enough not to interrupt a search, tight
+   * enough that it cannot be used to hammer Discord on our bot token.
+   */
+  discordRead: { rateLimit: { max: 60, timeWindow: "1 minute" } },
 } as const;
 
 /**
diff --git a/apps/dashboard/tests/client/features/automation/ActionFields.test.tsx b/apps/dashboard/tests/client/features/automation/ActionFields.test.tsx
new file mode 100644
index 00000000..79370001
--- /dev/null
+++ b/apps/dashboard/tests/client/features/automation/ActionFields.test.tsx
@@ -0,0 +1,142 @@
+// @vitest-environment jsdom
+import { describe, it, expect, vi } from "vitest";
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { ActionFields } from "../../../../src/client/features/automation/components/ActionFields";
+import type { ActionFieldDescriptor } from "../../../../src/client/shared/lib/schemas";
+
+function translate(key: string, opts?: Record<string, unknown>): string {
+  return opts ? `${key}:${JSON.stringify(opts)}` : key;
+}
+vi.mock("react-i18next", () => ({
+  useTranslation: () => ({ t: translate, i18n: { dir: () => "ltr" } }),
+}));
+
+global.ResizeObserver = class {
+  observe() {}
+  unobserve() {}
+  disconnect() {}
+};
+
+const headersField: ActionFieldDescriptor[] = [
+  { key: "webhook.headers", label: "Headers (JSON)", type: "json", maxLength: 1000 },
+];
+
+function renderHeaders(values: Record<string, unknown>, onChange = vi.fn()) {
+  render(
+    <ActionFields
+      fields={headersField}
+      values={values}
+      onChange={onChange}
+      channels={[]}
+      roles={[]}
+      variables={[]}
+    />,
+  );
+  return onChange;
+}
+
+/**
+ * `webhook.headers` is typed as a record, but the field wrote the raw textarea
+ * string straight into it. Typing the exact JSON the placeholder shows
+ * produced "Expected object, received string" on save — English-only, naming
+ * no field and no node — and nothing the user could type would ever save.
+ * The reverse was as bad: a rule that already had headers opened showing the
+ * literal text "[object Object]", and saving overwrote the real headers.
+ */
+describe("ActionFields — JSON fields", () => {
+  it("shows an existing header object as formatted JSON, not [object Object]", () => {
+    renderHeaders({ webhook: { headers: { "X-Request-Id": "abc" } } });
+
+    const field = screen.getByLabelText(/Headers/) as HTMLTextAreaElement;
+    expect(field.value).toContain("X-Request-Id");
+    expect(field.value).not.toContain("[object Object]");
+  });
+
+  it("commits a parsed object once the text is valid JSON", async () => {
+    const onChange = renderHeaders({});
+
+    const field = screen.getByLabelText(/Headers/);
+    await userEvent.click(field);
+    await userEvent.paste('{"X-Request-Id":"abc"}');
+
+    expect(onChange).toHaveBeenLastCalledWith("webhook.headers", { "X-Request-Id": "abc" });
+  });
+
+  it("flags invalid JSON instead of committing a string", async () => {
+    const onChange = renderHeaders({});
+
+    const field = screen.getByLabelText(/Headers/);
+    await userEvent.click(field);
+    await userEvent.paste("{not json");
+
+    expect(field).toHaveAttribute("aria-invalid", "true");
+    expect(screen.getByRole("alert")).toBeInTheDocument();
+    // Never hand the model a string for a field typed as a record.
+    for (const call of onChange.mock.calls) {
+      expect(typeof call[1]).not.toBe("string");
+    }
+  });
+
+  it("rejects valid JSON that is not an object of strings", async () => {
+    const onChange = renderHeaders({});
+
+    const field = screen.getByLabelText(/Headers/);
+    await userEvent.click(field);
+    await userEvent.paste('["a","b"]');
+
+    expect(field).toHaveAttribute("aria-invalid", "true");
+    for (const call of onChange.mock.calls) {
+      expect(Array.isArray(call[1])).toBe(false);
+    }
+  });
+
+  it("clears the field to undefined rather than an empty string", async () => {
+    const onChange = renderHeaders({ webhook: { headers: { a: "b" } } });
+
+    await userEvent.clear(screen.getByLabelText(/Headers/));
+
+    expect(onChange).toHaveBeenLastCalledWith("webhook.headers", undefined);
+  });
+});
+
+describe("ActionFields — required fields are announced, not just starred", () => {
+  // A red asterisk is the only signal a field is required, and nothing marks
+  // it invalid once left empty — so a screen-reader user gets no feedback at
+  // all about why Save is disabled.
+  it("marks an empty required field invalid and links its message", () => {
+    render(
+      <ActionFields
+        fields={[{ key: "channelId", label: "Channel", type: "text", required: true }]}
+        values={{}}
+        onChange={vi.fn()}
+        channels={[]}
+        roles={[]}
+        variables={[]}
+        showErrors
+      />,
+    );
+
+    const field = screen.getByLabelText(/Channel/);
+    expect(field).toHaveAttribute("aria-invalid", "true");
+    const describedBy = field.getAttribute("aria-describedby");
+    expect(describedBy).toBeTruthy();
+    expect(document.getElementById(describedBy!)).toHaveTextContent(/form\.fieldRequired/);
+  });
+
+  it("says nothing when the required field is filled", () => {
+    render(
+      <ActionFields
+        fields={[{ key: "channelId", label: "Channel", type: "text", required: true }]}
+        values={{ channelId: "123" }}
+        onChange={vi.fn()}
+        channels={[]}
+        roles={[]}
+        variables={[]}
+        showErrors
+      />,
+    );
+
+    expect(screen.getByLabelText(/Channel/)).not.toHaveAttribute("aria-invalid", "true");
+  });
+});
diff --git a/apps/dashboard/tests/client/features/automation/ConditionsEditor.test.tsx b/apps/dashboard/tests/client/features/automation/ConditionsEditor.test.tsx
new file mode 100644
index 00000000..7e3edd87
--- /dev/null
+++ b/apps/dashboard/tests/client/features/automation/ConditionsEditor.test.tsx
@@ -0,0 +1,160 @@
+// @vitest-environment jsdom
+import { describe, it, expect, vi } from "vitest";
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { ConditionsEditor } from "../../../../src/client/features/automation/components/ConditionsEditor";
+
+function translate(key: string, opts?: Record<string, unknown>): string {
+  return opts ? `${key}:${JSON.stringify(opts)}` : key;
+}
+vi.mock("react-i18next", () => ({
+  useTranslation: () => ({ t: translate, i18n: { dir: () => "ltr" } }),
+}));
+
+// DiscordMultiSelect fetches guild channels/roles; the group's presence is what
+// these tests assert, not its contents.
+vi.mock("../../../../src/client/shared/ui/discord-multi-select", () => ({
+  DiscordMultiSelect: ({ label, type }: { label: string; type: string }) => (
+    <div data-testid={`multiselect-${type}-${label}`}>{label}</div>
+  ),
+}));
+
+// The member picker queries the new /members endpoint; its own behaviour is
+// covered separately. Here only its presence per trigger matters.
+vi.mock("../../../../src/client/shared/ui/member-multi-select", () => ({
+  MemberMultiSelect: ({ label }: { label: string }) => (
+    <div data-testid={`memberselect-${label}`}>{label}</div>
+  ),
+}));
+
+global.ResizeObserver = class {
+  observe() {}
+  unobserve() {}
+  disconnect() {}
+};
+
+const noop = () => {};
+
+describe("ConditionsEditor — only offers filters the trigger can satisfy", () => {
+  // Filters fail closed (executor.ts matchesConditions), so offering a filter
+  // the event context can never answer does not merely do nothing — it
+  // silently stops the rule from ever firing.
+  it("hides channel filters for a trigger that carries no channel", () => {
+    render(
+      <ConditionsEditor
+        guildId="g1"
+        conditions={{}}
+        onChange={noop}
+        supported={["user", "role"]}
+        alwaysExpanded
+      />,
+    );
+
+    expect(screen.queryByTestId(/multiselect-any-/)).not.toBeInTheDocument();
+    // Role filters survive, in both the include and the exclude group.
+    expect(screen.getAllByTestId(/multiselect-role-/)).toHaveLength(2);
+  });
+
+  it("hides role filters for a trigger with no member in context", () => {
+    render(
+      <ConditionsEditor
+        guildId="g1"
+        conditions={{}}
+        onChange={noop}
+        supported={["user"]}
+        alwaysExpanded
+      />,
+    );
+
+    expect(screen.queryByTestId(/multiselect-role-/)).not.toBeInTheDocument();
+  });
+
+  it("hides user filters for a trigger with no acting user", () => {
+    render(
+      <ConditionsEditor
+        guildId="g1"
+        conditions={{}}
+        onChange={noop}
+        supported={["channel"]}
+        alwaysExpanded
+      />,
+    );
+
+    expect(screen.queryByTestId(/memberselect-/)).not.toBeInTheDocument();
+  });
+
+  it("offers everything when the trigger supports everything", () => {
+    render(
+      <ConditionsEditor
+        guildId="g1"
+        conditions={{}}
+        onChange={noop}
+        supported={["user", "role", "channel"]}
+        alwaysExpanded
+      />,
+    );
+
+    expect(screen.getAllByTestId(/multiselect-any-/)).toHaveLength(2);
+    expect(screen.getAllByTestId(/multiselect-role-/)).toHaveLength(2);
+  });
+
+  it("offers everything when no trigger is chosen yet", () => {
+    render(
+      <ConditionsEditor guildId="g1" conditions={{}} onChange={noop} alwaysExpanded />,
+    );
+
+    expect(screen.getAllByTestId(/multiselect-any-/)).toHaveLength(2);
+    expect(screen.getAllByTestId(/multiselect-role-/)).toHaveLength(2);
+  });
+});
+
+describe("ConditionsEditor — flags filters saved against an incompatible trigger", () => {
+  // A rule built before the trigger was changed (or before filters failed
+  // closed) can carry a filter its trigger can never satisfy. Because the
+  // runtime now refuses to fire it, the editor has to say so.
+  it("warns when a stored filter cannot be evaluated by the trigger", () => {
+    render(
+      <ConditionsEditor
+        guildId="g1"
+        conditions={{ channelIds: ["c1"] }}
+        onChange={noop}
+        supported={["user", "role"]}
+        alwaysExpanded
+      />,
+    );
+
+    expect(screen.getByRole("alert")).toHaveTextContent("conditions.unsupportedWarning");
+  });
+
+  it("offers to clear the filters that cannot apply", async () => {
+    const onChange = vi.fn();
+    render(
+      <ConditionsEditor
+        guildId="g1"
+        conditions={{ channelIds: ["c1"], userIds: ["u1"] }}
+        onChange={onChange}
+        supported={["user", "role"]}
+        alwaysExpanded
+      />,
+    );
+
+    await userEvent.click(screen.getByRole("button", { name: /conditions\.removeUnsupported/ }));
+
+    // The unusable channel filter goes; the usable user filter stays.
+    expect(onChange).toHaveBeenCalledWith({ userIds: ["u1"] });
+  });
+
+  it("stays quiet when every stored filter is supported", () => {
+    render(
+      <ConditionsEditor
+        guildId="g1"
+        conditions={{ userIds: ["u1"] }}
+        onChange={noop}
+        supported={["user", "role"]}
+        alwaysExpanded
+      />,
+    );
+
+    expect(screen.queryByRole("alert")).not.toBeInTheDocument();
+  });
+});
diff --git a/apps/dashboard/tests/client/features/automation/NodeDetailPanel.test.tsx b/apps/dashboard/tests/client/features/automation/NodeDetailPanel.test.tsx
new file mode 100644
index 00000000..ee0dcdda
--- /dev/null
+++ b/apps/dashboard/tests/client/features/automation/NodeDetailPanel.test.tsx
@@ -0,0 +1,250 @@
+// @vitest-environment jsdom
+import { describe, it, expect, vi } from "vitest";
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { NodeDetailPanel } from "../../../../src/client/features/automation/workflow/NodeDetailPanel";
+import type { Constants, RuleStep } from "../../../../src/client/shared/lib/schemas";
+
+// Stable passthrough translator — see the note in WorkflowEditor.test.tsx for
+// why identity stability matters in this tree.
+function translate(key: string, opts?: Record<string, unknown>): string {
+  return opts ? `${key}:${JSON.stringify(opts)}` : key;
+}
+vi.mock("react-i18next", () => ({
+  useTranslation: () => ({ t: translate, i18n: { dir: () => "ltr" } }),
+}));
+
+vi.mock("../../../../src/client/shared/hooks/useChannels", () => ({
+  useChannels: () => ({ data: [{ id: "c1", name: "general", type: 0 }] }),
+}));
+vi.mock("../../../../src/client/shared/hooks/useRoles", () => ({
+  useRoles: () => ({ data: [{ id: "r1", name: "Members" }] }),
+}));
+
+// usePreviewContext reads these two react-query hooks. `{user}` carries a
+// realKey, so the preview resolves it from buildRealData rather than the
+// descriptor's sample — with no session that yields "@User".
+vi.mock("../../../../src/client/shared/hooks/useAuth", () => ({
+  useAuth: () => ({ data: undefined }),
+}));
+vi.mock("../../../../src/client/shared/hooks/useGuilds", () => ({
+  useGuilds: () => ({ data: [] }),
+}));
+
+// Radix ScrollArea measures with ResizeObserver, absent in jsdom.
+global.ResizeObserver = class {
+  observe() {}
+  unobserve() {}
+  disconnect() {}
+};
+
+/**
+ * memberJoin carries no message tokens; messageCreated does. The gap between
+ * the two is what every assertion below turns on.
+ */
+const constants: Constants = {
+  eventTypes: {
+    memberJoin: { label: "Member Join", description: "" },
+    messageCreated: { label: "Message Sent", description: "" },
+  },
+  actionTypes: { sendMessage: { label: "Send Message", description: "" } },
+  maxActionsPerRule: 5,
+  actionTypeFields: {
+    sendMessage: [
+      { key: "channelId", label: "Channel", type: "channel", required: true },
+      { key: "message", label: "Message", type: "textarea", required: true },
+    ],
+  },
+  eventTypeVariables: {
+    memberJoin: ["{user}", "{guild}"],
+    messageCreated: ["{user}", "{guild}", "{message.content}"],
+  },
+  templateVariables: {
+    "{user}": "User mention",
+    "{guild}": "Server name",
+    "{message.content}": "Message content",
+    "{ban.reason}": "Ban reason",
+  },
+};
+
+const noop = () => {};
+
+async function openVariablesTab() {
+  await userEvent.click(await screen.findByRole("tab", { name: /panel\.variables/ }));
+}
+
+describe("NodeDetailPanel — action variables are scoped to the trigger", () => {
+  it("lists only the trigger's variables in a linear action's Variables tab", async () => {
+    render(
+      <NodeDetailPanel
+        type="action"
+        index={0}
+        action={{ type: "sendMessage" }}
+        constants={constants}
+        guildId="g1"
+        eventType="memberJoin"
+        totalActions={1}
+        onActionChange={noop}
+        onActionRemove={noop}
+        onActionMove={noop}
+        canRemove={false}
+        onClose={noop}
+      />,
+    );
+
+    await openVariablesTab();
+
+    expect(screen.getByText("{user}")).toBeInTheDocument();
+    expect(screen.getByText("{guild}")).toBeInTheDocument();
+    // memberJoin has no message and no ban context — offering these tokens
+    // tells the user to write a template the bot will render as "Unknown".
+    expect(screen.queryByText("{message.content}")).not.toBeInTheDocument();
+    expect(screen.queryByText("{ban.reason}")).not.toBeInTheDocument();
+  });
+
+  it("widens the list when the trigger provides more", async () => {
+    render(
+      <NodeDetailPanel
+        type="action"
+        index={0}
+        action={{ type: "sendMessage" }}
+        constants={constants}
+        guildId="g1"
+        eventType="messageCreated"
+        totalActions={1}
+        onActionChange={noop}
+        onActionRemove={noop}
+        onActionMove={noop}
+        canRemove={false}
+        onClose={noop}
+      />,
+    );
+
+    await openVariablesTab();
+
+    expect(screen.getByText("{message.content}")).toBeInTheDocument();
+    expect(screen.queryByText("{ban.reason}")).not.toBeInTheDocument();
+  });
+});
+
+describe("NodeDetailPanel — changing action type keeps what still applies", () => {
+  const shared: Constants = {
+    ...constants,
+    actionTypes: {
+      ...constants.actionTypes,
+      sendDM: { label: "Send DM", description: "" },
+      addRole: { label: "Add Role", description: "" },
+    },
+    actionTypeFields: {
+      ...constants.actionTypeFields,
+      // Both carry `message`; only sendMessage carries `channelId`.
+      sendDM: [{ key: "message", label: "Message", type: "textarea", required: true }],
+      addRole: [{ key: "roleId", label: "Role", type: "role", required: true }],
+    },
+  };
+
+  function renderAction(onActionChange: (i: number, a: unknown) => void) {
+    render(
+      <NodeDetailPanel
+        type="action"
+        index={0}
+        action={{ type: "sendMessage", channelId: "c1", message: "a long welcome" }}
+        constants={shared}
+        guildId="g1"
+        eventType="memberJoin"
+        totalActions={1}
+        onActionChange={onActionChange}
+        onActionRemove={noop}
+        onActionMove={noop}
+        canRemove={false}
+        onClose={noop}
+      />,
+    );
+  }
+
+  async function switchTo(label: string) {
+    // SearchableSelect's trigger is a plain <button id>, named by the <Label
+    // htmlFor> this change added — it had no accessible name at all before.
+    await userEvent.click(await screen.findByRole("button", { name: /panel\.actionType/i }));
+    await userEvent.click(await screen.findByText(label));
+  }
+
+  // Composing a 400-character welcome message under Send Message, realising it
+  // should be a DM, and switching type erased the message instantly — with no
+  // warning, no undo, and the draft autosave immediately persisting the empty
+  // action.
+  it("carries a field the new type also declares", async () => {
+    const onActionChange = vi.fn();
+    renderAction(onActionChange);
+
+    await switchTo("Send DM");
+
+    expect(onActionChange).toHaveBeenCalledWith(0, expect.objectContaining({
+      type: "sendDM",
+      message: "a long welcome",
+    }));
+  });
+
+  it("drops a field the new type does not declare", async () => {
+    const onActionChange = vi.fn();
+    renderAction(onActionChange);
+
+    await switchTo("Send DM");
+
+    expect(onActionChange.mock.calls[0][1]).not.toHaveProperty("channelId");
+  });
+
+  it("keeps nothing when the new type shares no fields", async () => {
+    const onActionChange = vi.fn();
+    renderAction(onActionChange);
+
+    await switchTo("Add Role");
+
+    expect(onActionChange).toHaveBeenCalledWith(0, { type: "addRole" });
+  });
+});
+
+describe("NodeDetailPanel — step-mode actions keep variables and preview", () => {
+  const steps: RuleStep[] = [
+    {
+      id: "step_0",
+      type: "action",
+      action: { type: "sendMessage", channelId: "c1", message: "hi {user}" },
+      next: null,
+    },
+  ];
+
+  function renderStep() {
+    return render(
+      <NodeDetailPanel
+        type="step"
+        stepId="step_0"
+        steps={steps}
+        constants={constants}
+        guildId="g1"
+        eventType="memberJoin"
+        onStepChange={noop}
+        onStepRemove={noop}
+        onClose={noop}
+      />,
+    );
+  }
+
+  // Adding a single condition or delay converts the whole rule to step mode.
+  // Before this, that silently stripped the variable reference and the message
+  // preview from every action in the rule.
+  it("offers a Variables tab scoped to the trigger", async () => {
+    renderStep();
+
+    await openVariablesTab();
+
+    expect(screen.getByText("{user}")).toBeInTheDocument();
+    expect(screen.queryByText("{message.content}")).not.toBeInTheDocument();
+  });
+
+  it("renders the Discord message preview for a sendMessage step", () => {
+    renderStep();
+
+    expect(screen.getByText("hi @User")).toBeInTheDocument();
+  });
+});
diff --git a/apps/dashboard/tests/client/features/automation/RuleList.test.tsx b/apps/dashboard/tests/client/features/automation/RuleList.test.tsx
index 0c14155e..affccf74 100644
--- a/apps/dashboard/tests/client/features/automation/RuleList.test.tsx
+++ b/apps/dashboard/tests/client/features/automation/RuleList.test.tsx
@@ -82,3 +82,61 @@ describe("RuleList accessibility", () => {
     ).toBeInTheDocument();
   });
 });
+
+/**
+ * A saved rule can be dead: an action missing a required field never executes,
+ * and the list showed it as perfectly healthy — "Never fired" with no
+ * explanation. Rules created before the save-time guard, or through the API
+ * and the /actions command, can still be in this state.
+ */
+describe("RuleList — incomplete rules are flagged", () => {
+  const constants = {
+    eventTypes: { memberJoin: { label: "Member Join", description: "" } },
+    actionTypes: { sendMessage: { label: "Send Message", description: "" } },
+    maxActionsPerRule: 5,
+    actionTypeFields: {
+      sendMessage: [
+        { key: "channelId", label: "Channel", type: "channel" as const, required: true },
+        { key: "message", label: "Message", type: "textarea" as const, required: true },
+      ],
+    },
+    eventTypeVariables: { memberJoin: [] },
+    templateVariables: {},
+    eventConditionSupport: { memberJoin: ["user" as const, "role" as const] },
+  };
+
+  function ruleWith(actions: unknown[]) {
+    return [{
+      id: 1, guildId: "g1", name: "R", enabled: true, eventType: "memberJoin",
+      actions, conditions: {}, priority: 0, createdBy: "u1", lastFired: null,
+    }];
+  }
+
+  function renderList(actions: unknown[]) {
+    render(
+      <RuleList
+        rules={ruleWith(actions) as never}
+        constants={constants as never}
+        onEdit={vi.fn()}
+        onDelete={vi.fn()}
+        onToggle={vi.fn()}
+        onDuplicate={vi.fn()}
+      />,
+    );
+  }
+
+  it("flags a rule whose action is missing a required field", () => {
+    renderList([{ type: "sendMessage", message: "hi" }]);
+    expect(screen.getByText("ruleList.misconfiguredBadge")).toBeInTheDocument();
+  });
+
+  it("flags a rule whose action has no type at all", () => {
+    renderList([{ type: "" }]);
+    expect(screen.getByText("ruleList.misconfiguredBadge")).toBeInTheDocument();
+  });
+
+  it("says nothing about a fully configured rule", () => {
+    renderList([{ type: "sendMessage", channelId: "c1", message: "hi" }]);
+    expect(screen.queryByText("ruleList.misconfiguredBadge")).not.toBeInTheDocument();
+  });
+});
diff --git a/apps/dashboard/tests/client/features/automation/WorkflowEditor.test.tsx b/apps/dashboard/tests/client/features/automation/WorkflowEditor.test.tsx
index a7d4b07e..ef769c9f 100644
--- a/apps/dashboard/tests/client/features/automation/WorkflowEditor.test.tsx
+++ b/apps/dashboard/tests/client/features/automation/WorkflowEditor.test.tsx
@@ -484,3 +484,121 @@ describe("WorkflowEditor — Ctrl+S does not bypass validation", () => {
     expect(updateMutateAsync).not.toHaveBeenCalled();
   });
 });
+
+
+/**
+ * The autosave effect wrote a draft for EVERY editor session, including one
+ * opened on an existing rule — but `loadDraft` is only consulted for new
+ * rules. So editing a rule and closing lost the edits outright, while the
+ * unread draft sat in localStorage until it expired.
+ */
+describe("WorkflowEditor — closing with unsaved changes", () => {
+  it("asks before discarding edits", async () => {
+    const user = userEvent.setup();
+    const onClose = vi.fn();
+    renderEditor(threeActions, onClose);
+
+    const nameField = await screen.findByLabelText(/editor\.ruleNamePlaceholder/);
+    await user.type(nameField, "X");
+
+    await user.click(screen.getByRole("button", { name: /editor\.backToRules/ }));
+
+    // A confirmation stands between the click and the close. ConfirmDialog is
+    // a Radix Dialog (role="dialog"), same as NodeDetailPanel, so assert on
+    // its title rather than the role.
+    expect(onClose).not.toHaveBeenCalled();
+    expect(await screen.findByText("editor.discardChangesTitle")).toBeInTheDocument();
+  });
+
+  it("closes once discarding is confirmed", async () => {
+    const user = userEvent.setup();
+    const onClose = vi.fn();
+    renderEditor(threeActions, onClose);
+
+    const nameField = await screen.findByLabelText(/editor\.ruleNamePlaceholder/);
+    await user.type(nameField, "X");
+    await user.click(screen.getByRole("button", { name: /editor\.backToRules/ }));
+    await user.click(await screen.findByRole("button", { name: /editor\.discardChanges/ }));
+
+    await waitFor(() => expect(onClose).toHaveBeenCalledTimes(1));
+  });
+
+  it("closes straight away when nothing has been touched", async () => {
+    const user = userEvent.setup();
+    const onClose = vi.fn();
+    renderEditor(threeActions, onClose);
+
+    await screen.findByLabelText(/editor\.ruleNamePlaceholder/);
+    await user.click(screen.getByRole("button", { name: /editor\.backToRules/ }));
+
+    expect(screen.queryByText("editor.discardChangesTitle")).not.toBeInTheDocument();
+    expect(onClose).toHaveBeenCalledTimes(1);
+  });
+});
+
+/**
+ * The only aggregate validation signal used to be a tooltip on a
+ * non-focusable div: keyboard and screen-reader users could not read it, the
+ * disabled Save button gave no reason at all, and with several actions there
+ * was no way to tell WHICH one was incomplete without opening each in turn.
+ */
+describe("WorkflowEditor — validation is reachable", () => {
+  // An action with no type chosen. That is an error anchored to `action-0`,
+  // and it needs no actionTypeFields entry — which this suite's shared
+  // constants deliberately leave empty.
+  const incomplete: RuleDraft = {
+    name: "Test Rule",
+    eventType: "messageCreate",
+    actions: [{ type: "" }],
+    conditions: {},
+    priority: 0,
+    enabled: true,
+  };
+
+  it("puts the issue count on a real button, not a bare div", async () => {
+    renderEditor(incomplete);
+
+    const trigger = await screen.findByRole("button", { name: /editor\.issues/ });
+    expect(trigger).toBeEnabled();
+  });
+
+  it("lists each issue when opened", async () => {
+    const user = userEvent.setup();
+    renderEditor(incomplete);
+
+    await user.click(await screen.findByRole("button", { name: /editor\.issues/ }));
+
+    const issues = await screen.findAllByText(/validation\.noActionType/);
+    expect(issues.length).toBeGreaterThan(0);
+  });
+
+  it("selects the offending node when an issue is chosen", async () => {
+    const user = userEvent.setup();
+    renderEditor(incomplete);
+
+    await user.click(await screen.findByRole("button", { name: /editor\.issues/ }));
+    const issue = (await screen.findAllByText(/validation\.noActionType/))[0];
+    await user.click(issue);
+
+    // The detail panel opens on the action the issue belongs to.
+    await waitFor(() => expect(panelHeading()).toContain("panel.action"));
+  });
+
+  it("explains why Save is disabled", async () => {
+    renderEditor(incomplete);
+
+    const save = await screen.findByRole("button", { name: /form\.create/ });
+    expect(save).toBeDisabled();
+    const describedBy = save.getAttribute("aria-describedby");
+    expect(describedBy).toBeTruthy();
+    expect(document.getElementById(describedBy!)).toHaveTextContent(/editor\.saveBlocked/);
+  });
+
+  it("says nothing about being blocked once the rule is valid", async () => {
+    renderEditor({ ...incomplete, actions: [{ type: "sendMessage", message: "hi" }] });
+
+    const save = await screen.findByRole("button", { name: /form\.create/ });
+    expect(save).toBeEnabled();
+    expect(save).not.toHaveAttribute("aria-describedby");
+  });
+});
diff --git a/apps/dashboard/tests/client/features/automation/labels.test.ts b/apps/dashboard/tests/client/features/automation/labels.test.ts
new file mode 100644
index 00000000..aef13ae8
--- /dev/null
+++ b/apps/dashboard/tests/client/features/automation/labels.test.ts
@@ -0,0 +1,80 @@
+import { describe, it, expect } from "vitest";
+import { makeAutomationLabels } from "../../../../src/client/features/automation/lib/labels";
+import type { Constants } from "../../../../src/client/shared/lib/schemas";
+
+const constants = {
+  eventTypes: { memberJoin: { label: "Member Join", description: "When a member joins" } },
+  actionTypes: { sendMessage: { label: "Send Message", description: "Send a message" } },
+  maxActionsPerRule: 5,
+  actionTypeFields: {},
+  eventTypeVariables: {},
+  templateVariables: {},
+  eventConditionSupport: {},
+} as unknown as Constants;
+
+/** Stands in for i18next: returns a translation only for the keys it knows. */
+function translator(dict: Record<string, string>) {
+  return (key: string, params?: Record<string, unknown>) =>
+    dict[key] ?? (params?.defaultValue as string | undefined) ?? key;
+}
+
+/**
+ * EVENT_TYPES / ACTION_TYPES / ACTION_TYPE_FIELDS are hardcoded English in
+ * packages/systems and served raw by the API, because the bot needs them too.
+ * That made the whole automation builder English-only in a 48-locale app.
+ * The client translates them on the way out, falling back to the API's
+ * English so an untranslated locale degrades to the old behaviour rather than
+ * rendering blanks.
+ */
+describe("automation label resolver", () => {
+  it("prefers the translation when the locale has one", () => {
+    const labels = makeAutomationLabels(
+      translator({ "eventTypes.memberJoin.label": "Mitglied beigetreten" }),
+      constants,
+    );
+    expect(labels.eventLabel("memberJoin")).toBe("Mitglied beigetreten");
+  });
+
+  it("falls back to the API's English when the locale has none", () => {
+    const labels = makeAutomationLabels(translator({}), constants);
+    expect(labels.eventLabel("memberJoin")).toBe("Member Join");
+    expect(labels.actionLabel("sendMessage")).toBe("Send Message");
+  });
+
+  it("treats an empty translation as missing", () => {
+    const labels = makeAutomationLabels(
+      translator({ "eventTypes.memberJoin.label": "" }),
+      constants,
+    );
+    expect(labels.eventLabel("memberJoin")).toBe("Member Join");
+  });
+
+  it("falls back to the raw key for an event the API does not know", () => {
+    const labels = makeAutomationLabels(translator({}), constants);
+    expect(labels.eventLabel("somethingNew")).toBe("somethingNew");
+  });
+
+  it("translates descriptions too", () => {
+    const labels = makeAutomationLabels(
+      translator({ "actionTypes.sendMessage.description": "Envoie un message" }),
+      constants,
+    );
+    expect(labels.actionDescription("sendMessage")).toBe("Envoie un message");
+  });
+
+  // Field keys contain dots, which i18next reads as key nesting.
+  it("escapes dots in field keys so nested paths do not break lookup", () => {
+    const labels = makeAutomationLabels(
+      translator({ "actionFields.sendWebhook_webhook_url.label": "URL du webhook" }),
+      constants,
+    );
+    expect(labels.fieldLabel("sendWebhook", "webhook.url", "Webhook URL")).toBe(
+      "URL du webhook",
+    );
+  });
+
+  it("leaves an absent placeholder absent rather than inventing one", () => {
+    const labels = makeAutomationLabels(translator({}), constants);
+    expect(labels.fieldPlaceholder("addRole", "roleId", undefined)).toBeUndefined();
+  });
+});
diff --git a/apps/dashboard/tests/client/features/automation/nodeValidationState.test.tsx b/apps/dashboard/tests/client/features/automation/nodeValidationState.test.tsx
new file mode 100644
index 00000000..34618e24
--- /dev/null
+++ b/apps/dashboard/tests/client/features/automation/nodeValidationState.test.tsx
@@ -0,0 +1,83 @@
+// @vitest-environment jsdom
+import { describe, it, expect, vi } from "vitest";
+import { render, screen } from "@testing-library/react";
+import { ReactFlowProvider } from "@xyflow/react";
+import { ConditionNode } from "../../../../src/client/features/automation/workflow/nodes/ConditionNode";
+import { DelayNode } from "../../../../src/client/features/automation/workflow/nodes/DelayNode";
+
+vi.mock("react-i18next", () => ({
+  useTranslation: () => ({ t: (k: string) => k, i18n: { dir: () => "ltr" } }),
+}));
+
+global.ResizeObserver = class {
+  observe() {}
+  unobserve() {}
+  disconnect() {}
+};
+
+/**
+ * Returns the node's card — the element with role="group". Neither
+ * `firstElementChild` nor "any element with a border class" works: ReactFlow
+ * renders its connection handles as siblings before the card, and they carry
+ * their own borders. Querying the wrong element made one of these assertions
+ * pass spuriously.
+ */
+function renderNode(node: React.ReactNode) {
+  render(<ReactFlowProvider>{node}</ReactFlowProvider>);
+  return screen.getByRole("group");
+}
+
+/**
+ * validateSteps emits warnings for a condition with no value, a condition with
+ * no branches, an unconnected delay and an unreachable step — but only
+ * ActionNode and TriggerNode rendered a `warning` border. On the canvas those
+ * warnings were invisible, so the toolbar said "3 issues" and nothing on
+ * screen said which node.
+ */
+describe("condition and delay nodes surface their warning state", () => {
+  const conditionData = {
+    condition: { field: "channelId", operator: "equals", value: "" },
+    validationState: "warning" as const,
+  };
+
+  it("ConditionNode marks its warning state and announces it", () => {
+    const el = renderNode(
+      <ConditionNode data={conditionData} selected={false} {...({} as never)} />,
+    );
+    expect(el).toHaveAttribute("data-validation", "warning");
+    expect(screen.getByLabelText("nodes.hasWarning")).toBeInTheDocument();
+  });
+
+  it("ConditionNode distinguishes an error from a warning", () => {
+    const el = renderNode(
+      <ConditionNode
+        data={{ ...conditionData, validationState: "error" }}
+        selected={false}
+        {...({} as never)}
+      />,
+    );
+    expect(el).toHaveAttribute("data-validation", "error");
+    expect(screen.getByLabelText("nodes.hasError")).toBeInTheDocument();
+  });
+
+  it("DelayNode marks its warning state and announces it", () => {
+    const el = renderNode(
+      <DelayNode
+        data={{ delayMs: 5000, validationState: "warning" }}
+        selected={false}
+        {...({} as never)}
+      />,
+    );
+    expect(el).toHaveAttribute("data-validation", "warning");
+    expect(screen.getByLabelText("nodes.hasWarning")).toBeInTheDocument();
+  });
+
+  it("says nothing when there is nothing wrong", () => {
+    const el = renderNode(
+      <DelayNode data={{ delayMs: 5000, validationState: null }} selected={false} {...({} as never)} />,
+    );
+    expect(el).not.toHaveAttribute("data-validation");
+    expect(screen.queryByLabelText("nodes.hasWarning")).not.toBeInTheDocument();
+    expect(screen.queryByLabelText("nodes.hasError")).not.toBeInTheDocument();
+  });
+});
diff --git a/apps/dashboard/tests/client/features/automation/useWorkflowKeyboard.test.ts b/apps/dashboard/tests/client/features/automation/useWorkflowKeyboard.test.ts
index 0852766f..1998ca11 100644
--- a/apps/dashboard/tests/client/features/automation/useWorkflowKeyboard.test.ts
+++ b/apps/dashboard/tests/client/features/automation/useWorkflowKeyboard.test.ts
@@ -104,3 +104,73 @@ describe("useWorkflowKeyboard while the context menu is open", () => {
     expect(opts.onClose).not.toHaveBeenCalled();
   });
 });
+
+/**
+ * Escape was explicitly allowed through from form controls, and Escape with
+ * no node selected closes the whole editor. So typing a rule name and
+ * pressing Escape out of habit to revert the field tore down the full-screen
+ * editor — and for an existing rule that discarded every unsaved edit, since
+ * the per-rule draft is never read back.
+ */
+describe("useWorkflowKeyboard — Escape inside a form control", () => {
+  function withFocusedInput(tag: "input" | "textarea" | "select") {
+    const el = document.createElement(tag);
+    document.body.appendChild(el);
+    el.focus();
+    return el;
+  }
+
+  it("blurs the field instead of closing the editor", () => {
+    const opts = setup();
+    const input = withFocusedInput("input");
+
+    press("Escape", {}, input);
+
+    expect(opts.onClose).not.toHaveBeenCalled();
+    expect(document.activeElement).not.toBe(input);
+  });
+
+  it("does not deselect the open node either", () => {
+    const opts = setup({ selectedNode: { type: "action", index: 0 } });
+    const input = withFocusedInput("input");
+
+    press("Escape", {}, input);
+
+    expect(opts.onDeselectNode).not.toHaveBeenCalled();
+    expect(opts.onClose).not.toHaveBeenCalled();
+  });
+
+  it("applies to textareas and selects too", () => {
+    const opts = setup();
+    for (const tag of ["textarea", "select"] as const) {
+      press("Escape", {}, withFocusedInput(tag));
+    }
+    expect(opts.onClose).not.toHaveBeenCalled();
+  });
+
+  it("still closes the editor when Escape comes from the canvas", () => {
+    const opts = setup();
+
+    press("Escape");
+
+    expect(opts.onClose).toHaveBeenCalledTimes(1);
+  });
+
+  it("still deselects an open node when Escape comes from the canvas", () => {
+    const opts = setup({ selectedNode: { type: "action", index: 0 } });
+
+    press("Escape");
+
+    expect(opts.onDeselectNode).toHaveBeenCalledTimes(1);
+    expect(opts.onClose).not.toHaveBeenCalled();
+  });
+
+  it("keeps Ctrl+S working from inside a field", () => {
+    const opts = setup();
+    const input = withFocusedInput("input");
+
+    press("s", { ctrlKey: true }, input);
+
+    expect(opts.onSubmit).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/apps/dashboard/tests/client/features/automation/useWorkflowSteps.test.ts b/apps/dashboard/tests/client/features/automation/useWorkflowSteps.test.ts
index 019460b1..3955524b 100644
--- a/apps/dashboard/tests/client/features/automation/useWorkflowSteps.test.ts
+++ b/apps/dashboard/tests/client/features/automation/useWorkflowSteps.test.ts
@@ -187,3 +187,52 @@ describe("snapshot and restore", () => {
     expect(result.current.actions[0]).toMatchObject({ type: "sendMessage", message: "hi" });
   });
 });
+
+/**
+ * React Flow delivers one `remove` change per node in a multi-select Delete,
+ * and WorkflowEditor applied each by index in a loop. Every removal splices
+ * the array, so from the second one onward the index referred to a different
+ * action — deleting nodes 0 and 2 removed actions 0 and 3. Removing the whole
+ * set in one pass is the only way indices stay meaningful.
+ */
+describe("useWorkflowSteps — removing several actions at once", () => {
+  const four: ActionConfig[] = [
+    { type: "sendMessage", message: "zero" },
+    { type: "sendMessage", message: "one" },
+    { type: "sendMessage", message: "two" },
+    { type: "sendMessage", message: "three" },
+  ];
+
+  it("removes exactly the given indices, not their post-splice neighbours", () => {
+    const { result } = setup({ initialActions: four });
+
+    act(() => { result.current.handleActionsRemove([0, 2]); });
+
+    expect(result.current.actions.map((a) => a.message)).toEqual(["one", "three"]);
+  });
+
+  it("is order-independent", () => {
+    const { result } = setup({ initialActions: four });
+
+    act(() => { result.current.handleActionsRemove([2, 0]); });
+
+    expect(result.current.actions.map((a) => a.message)).toEqual(["one", "three"]);
+  });
+
+  it("ignores indices that do not exist", () => {
+    const { result } = setup({ initialActions: four });
+
+    act(() => { result.current.handleActionsRemove([1, 99]); });
+
+    expect(result.current.actions.map((a) => a.message)).toEqual(["zero", "two", "three"]);
+  });
+
+  it("never empties the list — the last surviving action is reset instead", () => {
+    const { result } = setup({ initialActions: four });
+
+    act(() => { result.current.handleActionsRemove([0, 1, 2, 3]); });
+
+    expect(result.current.actions).toHaveLength(1);
+    expect(result.current.actions[0]).toEqual({ type: "" });
+  });
+});
diff --git a/apps/dashboard/tests/client/features/automation/workflow-validation.test.ts b/apps/dashboard/tests/client/features/automation/workflow-validation.test.ts
index c3f80edb..dbfe0ce9 100644
--- a/apps/dashboard/tests/client/features/automation/workflow-validation.test.ts
+++ b/apps/dashboard/tests/client/features/automation/workflow-validation.test.ts
@@ -1,11 +1,39 @@
 import { describe, it, expect } from "vitest";
 import { validateWorkflow } from "../../../../src/client/features/automation/lib/workflow-validation";
-import type { RuleStep } from "../../../../src/client/shared/lib/schemas";
+import type { Constants, RuleStep } from "../../../../src/client/shared/lib/schemas";
 
 // validateWorkflow takes the structural TranslateFn, so a plain passthrough
 // needs no cast.
 const t = (key: string) => key;
 
+/**
+ * Minimal constants carrying only what validateAction reads —
+ * `actionTypeFields`. Mirrors ACTION_TYPE_FIELDS in
+ * packages/systems/src/actions/constants.ts for the action types under test.
+ */
+const constants: Constants = {
+  eventTypes: { memberJoin: { label: "Member Join", description: "" } },
+  actionTypes: {
+    sendMessage: { label: "Send Message", description: "" },
+    addRole: { label: "Add Role", description: "" },
+    sendWebhook: { label: "Send Webhook", description: "" },
+  },
+  maxActionsPerRule: 5,
+  actionTypeFields: {
+    sendMessage: [
+      { key: "channelId", label: "Channel", type: "channel", required: true },
+      { key: "message", label: "Message", type: "textarea", required: true },
+    ],
+    addRole: [{ key: "roleId", label: "Role", type: "role", required: true }],
+    sendWebhook: [
+      { key: "webhook.url", label: "Webhook URL", type: "text", required: true },
+      { key: "webhook.method", label: "HTTP Method", type: "select" },
+    ],
+  },
+  eventTypeVariables: { memberJoin: ["{user}"] },
+  templateVariables: { "{user}": "User mention" },
+};
+
 const graph: RuleStep[] = [
   { id: "step_0", type: "action", action: { type: "sendMessage", message: "hi" }, next: "step_1" },
   { id: "step_1", type: "condition", condition: { field: "channelId", operator: "equals", value: "9" }, thenNext: "step_2", elseNext: null },
@@ -37,3 +65,87 @@ describe("validateWorkflow — entry-less step graph", () => {
     expect(result.issues.some((i) => i.message === "validation.noEntryStep")).toBe(false);
   });
 });
+
+describe("validateWorkflow — required action fields block save", () => {
+  it.each([
+    ["sendMessage with no channel and no message", { type: "sendMessage" }],
+    ["sendMessage with a channel but no message", { type: "sendMessage", channelId: "1" }],
+    ["addRole with no role", { type: "addRole" }],
+    ["sendWebhook with no url", { type: "sendWebhook", webhook: { url: "" } }],
+  ])("rejects %s", (_label, action) => {
+    const result = validateWorkflow("memberJoin", [action], "Test Rule", constants, t, undefined, undefined);
+
+    expect(result.valid).toBe(false);
+    expect(
+      result.issues.some(
+        (i) => i.level === "error" && i.message === "validation.fieldRequired",
+      ),
+    ).toBe(true);
+  });
+
+  it("anchors the error to the action's node so the canvas can highlight it", () => {
+    const result = validateWorkflow("memberJoin", [{ type: "addRole" }], "Test Rule", constants, t);
+
+    expect(result.issues).toContainEqual({
+      nodeId: "action-0",
+      level: "error",
+      message: "validation.fieldRequired",
+    });
+  });
+
+  it("accepts an action once every required field is filled", () => {
+    const result = validateWorkflow(
+      "memberJoin",
+      [{ type: "sendMessage", channelId: "123", message: "hi" }],
+      "Test Rule",
+      constants,
+      t,
+    );
+
+    expect(result.valid).toBe(true);
+    expect(result.issues).toEqual([]);
+  });
+
+  it("ignores optional fields left empty", () => {
+    const result = validateWorkflow(
+      "memberJoin",
+      [{ type: "sendWebhook", webhook: { url: "https://example.com" } }],
+      "Test Rule",
+      constants,
+      t,
+    );
+
+    expect(result.valid).toBe(true);
+  });
+
+  it("blocks save for an action step inside a graph, not just a linear action", () => {
+    const steps: RuleStep[] = [
+      { id: "step_0", type: "action", action: { type: "addRole" }, next: null },
+    ];
+    const result = validateWorkflow("memberJoin", [], "Test Rule", constants, t, steps, "step_0");
+
+    expect(result.valid).toBe(false);
+    expect(result.issues).toContainEqual({
+      nodeId: "step-step_0",
+      level: "error",
+      message: "validation.fieldRequired",
+    });
+  });
+
+  it("keeps advisory graph issues as warnings so the error/warning split stays meaningful", () => {
+    const steps: RuleStep[] = [
+      { id: "step_0", type: "action", action: { type: "addRole", roleId: "1" }, next: "step_1" },
+      {
+        id: "step_1",
+        type: "condition",
+        condition: { field: "channelId", operator: "equals", value: "" },
+        thenNext: null,
+        elseNext: null,
+      },
+    ];
+    const result = validateWorkflow("memberJoin", [], "Test Rule", constants, t, steps, "step_0");
+
+    expect(result.valid).toBe(true);
+    expect(result.issues.every((i) => i.level === "warning")).toBe(true);
+  });
+});
diff --git a/apps/dashboard/tests/client/shared/lib/channelTypes.test.ts b/apps/dashboard/tests/client/shared/lib/channelTypes.test.ts
new file mode 100644
index 00000000..2d73b790
--- /dev/null
+++ b/apps/dashboard/tests/client/shared/lib/channelTypes.test.ts
@@ -0,0 +1,52 @@
+import { describe, it, expect } from "vitest";
+import {
+  CHANNEL_TYPE,
+  isMessageableChannel,
+  channelIconName,
+} from "../../../../src/client/shared/lib/channelTypes";
+
+/**
+ * Three components each hardcoded their own idea of "a channel you can post
+ * to" (`c.type === 0 || c.type === 2`), which silently excluded announcement,
+ * stage and forum channels everywhere. A rule could not be scoped to an
+ * announcement channel, and a Send Message action could not target one.
+ */
+describe("isMessageableChannel", () => {
+  it("accepts every channel type a message or filter can target", () => {
+    for (const type of [
+      CHANNEL_TYPE.GuildText,
+      CHANNEL_TYPE.GuildVoice,
+      CHANNEL_TYPE.GuildAnnouncement,
+      CHANNEL_TYPE.GuildStageVoice,
+      CHANNEL_TYPE.GuildForum,
+      CHANNEL_TYPE.GuildMedia,
+    ]) {
+      expect(isMessageableChannel(type), String(type)).toBe(true);
+    }
+  });
+
+  it("rejects categories, which hold no messages", () => {
+    expect(isMessageableChannel(CHANNEL_TYPE.GuildCategory)).toBe(false);
+  });
+
+  it("rejects unknown types rather than guessing", () => {
+    expect(isMessageableChannel(999)).toBe(false);
+  });
+});
+
+describe("channelIconName", () => {
+  it("distinguishes voice, stage, announcement, forum and text", () => {
+    const names = new Set([
+      channelIconName(CHANNEL_TYPE.GuildVoice),
+      channelIconName(CHANNEL_TYPE.GuildStageVoice),
+      channelIconName(CHANNEL_TYPE.GuildAnnouncement),
+      channelIconName(CHANNEL_TYPE.GuildForum),
+      channelIconName(CHANNEL_TYPE.GuildText),
+    ]);
+    expect(names.size).toBe(5);
+  });
+
+  it("falls back to the text icon for anything unrecognised", () => {
+    expect(channelIconName(999)).toBe(channelIconName(CHANNEL_TYPE.GuildText));
+  });
+});
diff --git a/apps/dashboard/tests/server/features/actions/actions.test.ts b/apps/dashboard/tests/server/features/actions/actions.test.ts
index 76844d16..08b94d48 100644
--- a/apps/dashboard/tests/server/features/actions/actions.test.ts
+++ b/apps/dashboard/tests/server/features/actions/actions.test.ts
@@ -76,14 +76,11 @@ vi.mock("@fluxcore/systems/actions/config", () => ({
   setGuildSettings: (...args: unknown[]) => mockSetGuildSettings(...args),
 }));
 
-vi.mock("@fluxcore/systems/actions/constants", () => ({
-  EVENT_TYPES: { memberJoin: { label: "Member Join" }, memberLeave: { label: "Member Leave" } },
-  ACTION_TYPES: { sendMessage: { label: "Send Message" }, addRole: { label: "Add Role" } },
-  MAX_ACTIONS_PER_RULE: 5,
-  ACTION_TYPE_FIELDS: {},
-  EVENT_TYPE_VARIABLES: {},
-  TEMPLATE_VARIABLES: [],
-}));
+// `@fluxcore/systems/actions/constants` is deliberately NOT mocked. It is pure
+// data with no I/O, and it is the single source of truth the route validates
+// against — a stubbed ACTION_TYPE_FIELDS would make these tests assert a
+// fiction (it previously did: the required-field contract was invisible, and
+// half the action types read as "invalid action type").
 
 vi.mock("@fluxcore/utils", () => ({
   logger: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
@@ -125,6 +122,25 @@ describe("action routes", () => {
       expect(body.actionTypes).toBeDefined();
       expect(body.maxActionsPerRule).toBe(5);
     });
+
+    // Filters fail closed, so the editor must know which of them a given
+    // trigger can actually satisfy — otherwise it lets users build a rule that
+    // silently never fires.
+    it("exposes which filter subjects each event type supports", async () => {
+      const res = await app.inject({
+        method: "GET",
+        url: "/api/actions/constants",
+        cookies: { session: app.signCookie("valid") },
+      });
+      const body = res.json();
+
+      expect(body.eventConditionSupport).toBeDefined();
+      expect(body.eventConditionSupport.memberJoin).toEqual(
+        expect.arrayContaining(["user", "role"]),
+      );
+      expect(body.eventConditionSupport.memberJoin).not.toContain("channel");
+      expect(body.eventConditionSupport.memberBanned).not.toContain("role");
+    });
   });
 
   describe("GET /api/guilds/:guildId/actions/rules", () => {
@@ -219,14 +235,82 @@ describe("action routes", () => {
         payload: {
           name: "test",
           eventType: "memberJoin",
-          actions: [{ type: "sendMessage" }],
+          actions: [{ type: "sendMessage", channelId: "1", message: "hi" }],
         },
       });
       expect(res.statusCode).toBe(400);
       expect(res.json().error).toContain("Rule limit reached");
     });
 
-    it("validates sendWebhook requires HTTPS URL", async () => {
+    it("rejects sendWebhook over plain HTTP", async () => {
+      const res = await app.inject({
+        method: "POST",
+        url: "/api/guilds/guild-1/actions/rules",
+        cookies: { session: app.signCookie("valid") },
+        payload: {
+          name: "test",
+          eventType: "memberJoin",
+          actions: [{ type: "sendWebhook", webhook: { url: "http://example.com/hook" } }],
+        },
+      });
+      expect(res.statusCode).toBe(400);
+      expect(res.json().error).toContain("HTTPS");
+    });
+
+    it("accepts sendWebhook over HTTPS", async () => {
+      const res = await app.inject({
+        method: "POST",
+        url: "/api/guilds/guild-1/actions/rules",
+        cookies: { session: app.signCookie("valid") },
+        payload: {
+          name: "test",
+          eventType: "memberJoin",
+          actions: [{ type: "sendWebhook", webhook: { url: "https://example.com/hook" } }],
+        },
+      });
+      expect(res.statusCode).toBe(201);
+    });
+  });
+
+  // The client's Save button is only one gate, and it is not the one that
+  // matters: the Undo-delete and Duplicate paths in rules.tsx re-POST a stored
+  // action list without revalidating, and the API is public to any script. A
+  // rule missing a required field can never execute, so the server must be the
+  // one that refuses it.
+  describe("POST /api/guilds/:guildId/actions/rules — required action fields", () => {
+    it.each([
+      ["sendMessage without a channel", { type: "sendMessage", message: "hi" }, "Channel"],
+      ["sendMessage without a message", { type: "sendMessage", channelId: "1" }, "Message"],
+      ["addRole without a role", { type: "addRole" }, "Role"],
+      ["setNickname without a nickname", { type: "setNickname" }, "Nickname"],
+      ["createThread without a thread name", { type: "createThread", channelId: "1" }, "Thread Name"],
+      ["addReaction without an emoji", { type: "addReaction" }, "Emoji"],
+    ])("rejects %s", async (_label, action, expectedField) => {
+      const res = await app.inject({
+        method: "POST",
+        url: "/api/guilds/guild-1/actions/rules",
+        cookies: { session: app.signCookie("valid") },
+        payload: { name: "test", eventType: "memberJoin", actions: [action] },
+      });
+      expect(res.statusCode).toBe(400);
+      expect(res.json().error).toContain(expectedField);
+    });
+
+    it("accepts an action with every required field filled", async () => {
+      const res = await app.inject({
+        method: "POST",
+        url: "/api/guilds/guild-1/actions/rules",
+        cookies: { session: app.signCookie("valid") },
+        payload: {
+          name: "test",
+          eventType: "memberJoin",
+          actions: [{ type: "sendMessage", channelId: "1", message: "hi" }],
+        },
+      });
+      expect(res.statusCode).toBe(201);
+    });
+
+    it("treats a whitespace-only required field as missing", async () => {
       const res = await app.inject({
         method: "POST",
         url: "/api/guilds/guild-1/actions/rules",
@@ -234,10 +318,60 @@ describe("action routes", () => {
         payload: {
           name: "test",
           eventType: "memberJoin",
-          actions: [{ type: "sendMessage" }, { type: "sendMessage" }],
+          actions: [{ type: "sendMessage", channelId: "1", message: "   " }],
+        },
+      });
+      expect(res.statusCode).toBe(400);
+    });
+
+    // The bot executes `steps` in preference to `actions` (executor.ts:274),
+    // so validating only `actions` leaves the path that actually runs unchecked.
+    it("rejects an action step whose required field is empty", async () => {
+      const res = await app.inject({
+        method: "POST",
+        url: "/api/guilds/guild-1/actions/rules",
+        cookies: { session: app.signCookie("valid") },
+        payload: {
+          name: "test",
+          eventType: "memberJoin",
+          actions: [{ type: "sendMessage", channelId: "1", message: "hi" }],
+          entryStepId: "step_0",
+          steps: [{ id: "step_0", type: "action", action: { type: "addRole" }, next: null }],
+        },
+      });
+      expect(res.statusCode).toBe(400);
+      expect(res.json().error).toContain("Role");
+    });
+
+    it("rejects an unknown action type inside a step", async () => {
+      const res = await app.inject({
+        method: "POST",
+        url: "/api/guilds/guild-1/actions/rules",
+        cookies: { session: app.signCookie("valid") },
+        payload: {
+          name: "test",
+          eventType: "memberJoin",
+          actions: [{ type: "sendMessage", channelId: "1", message: "hi" }],
+          entryStepId: "step_0",
+          steps: [{ id: "step_0", type: "action", action: { type: "nope" }, next: null }],
+        },
+      });
+      expect(res.statusCode).toBe(400);
+    });
+
+    it("accepts a valid step graph", async () => {
+      const res = await app.inject({
+        method: "POST",
+        url: "/api/guilds/guild-1/actions/rules",
+        cookies: { session: app.signCookie("valid") },
+        payload: {
+          name: "test",
+          eventType: "memberJoin",
+          actions: [{ type: "addRole", roleId: "7" }],
+          entryStepId: "step_0",
+          steps: [{ id: "step_0", type: "action", action: { type: "addRole", roleId: "7" }, next: null }],
         },
       });
-      // Should pass as sendMessage doesn't need webhook
       expect(res.statusCode).toBe(201);
     });
   });
@@ -319,4 +453,104 @@ describe("action routes", () => {
       });
     });
   });
+
+/**
+ * The rule name reaches Discord embeds, `/actions` autocomplete and audit
+ * logs. The bot command guards it with RULE_NAME_REGEX; the dashboard API
+ * guarded it only for length, so the stated injection protection was
+ * bypassable by anything that did not go through Discord.
+ *
+ * The API cannot simply reuse that regex — it is ASCII-only, and our own
+ * preset templates produce non-ASCII names in 47 of 48 locales.
+ */
+describe("POST /api/guilds/:guildId/actions/rules — rule name safety", () => {
+  function post(name: string) {
+    return app.inject({
+      method: "POST",
+      url: "/api/guilds/guild-1/actions/rules",
+      cookies: { session: app.signCookie("valid") },
+      payload: {
+        name,
+        eventType: "memberJoin",
+        actions: [{ type: "sendMessage", channelId: "1", message: "hi" }],
+      },
+    });
+  }
+
+  it.each([
+    ["@everyone", "@everyone ping"],
+    ["a backtick code fence", "rule ``` here"],
+    ["a zero-width character", "rule​name"],
+    ["a right-to-left override", "rule\u202Ename"],
+    ["a mention", "<@123456789012345678>"],
+    ["a newline", "line one\nline two"],
+  ])("rejects %s", async (_label, name) => {
+    const res = await post(name);
+    expect(res.statusCode).toBe(400);
+  });
+
+  it.each([
+    ["plain ASCII", "Welcome Rule"],
+    ["Arabic", "قاعدة الترحيب"],
+    ["Japanese", "ようこそルール"],
+    ["accented Latin", "Règle de bienvenue"],
+  ])("accepts %s", async (_label, name) => {
+    const res = await post(name);
+    expect(res.statusCode).toBe(201);
+  });
+});
+
+describe("POST /api/guilds/:guildId/actions/rules — trigger conditions", () => {
+  function postConditions(conditions: unknown) {
+    return app.inject({
+      method: "POST",
+      url: "/api/guilds/guild-1/actions/rules",
+      cookies: { session: app.signCookie("valid") },
+      payload: {
+        name: "test",
+        eventType: "memberJoin",
+        actions: [{ type: "sendMessage", channelId: "1", message: "hi" }],
+        conditions,
+      },
+    });
+  }
+
+  it("rejects a condition value that is not a snowflake", async () => {
+    const res = await postConditions({ roleIds: ["not-an-id"] });
+    expect(res.statusCode).toBe(400);
+  });
+
+  it("rejects an unknown condition key", async () => {
+    const res = await postConditions({ nonsenseIds: ["123456789012345678"] });
+    expect(res.statusCode).toBe(400);
+  });
+
+  it("accepts well-formed snowflakes", async () => {
+    const res = await postConditions({ roleIds: ["123456789012345678"] });
+    expect(res.statusCode).toBe(201);
+  });
+});
+
+describe("POST /api/guilds/:guildId/actions/rules — duplicate names", () => {
+  // A duplicate name hit Prisma's P2002 unhandled, surfacing as a 500 with a
+  // generic client message that told the user nothing actionable.
+  it("returns 409 with a readable message, not a 500", async () => {
+    const conflict = Object.assign(new Error("Unique constraint failed"), { code: "P2002" });
+    mockCreateRule.mockRejectedValueOnce(conflict);
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/api/guilds/guild-1/actions/rules",
+      cookies: { session: app.signCookie("valid") },
+      payload: {
+        name: "duplicate",
+        eventType: "memberJoin",
+        actions: [{ type: "sendMessage", channelId: "1", message: "hi" }],
+      },
+    });
+
+    expect(res.statusCode).toBe(409);
+    expect(res.json().error).toMatch(/name/i);
+  });
+});
 });
diff --git a/apps/dashboard/tests/server/features/actions/updateRuleErrors.test.ts b/apps/dashboard/tests/server/features/actions/updateRuleErrors.test.ts
index 541c79c1..7b9e3831 100644
--- a/apps/dashboard/tests/server/features/actions/updateRuleErrors.test.ts
+++ b/apps/dashboard/tests/server/features/actions/updateRuleErrors.test.ts
@@ -54,14 +54,10 @@ vi.mock("@fluxcore/systems/actions/config", () => ({
   setGuildSettings: vi.fn().mockResolvedValue(undefined),
 }));
 
-vi.mock("@fluxcore/systems/actions/constants", () => ({
-  EVENT_TYPES: { memberJoin: { label: "Member Join" } },
-  ACTION_TYPES: { sendMessage: { label: "Send Message" } },
-  MAX_ACTIONS_PER_RULE: 5,
-  ACTION_TYPE_FIELDS: {},
-  EVENT_TYPE_VARIABLES: {},
-  TEMPLATE_VARIABLES: [],
-}));
+// Not mocked, for the same reason as in actions.test.ts: this module is pure
+// data and is the contract the route validates against. A stub silently drops
+// whatever the route starts importing next (it dropped isSafeRuleName), and
+// the route then fails for a reason the test was never written to check.
 
 const { mockLogger } = vi.hoisted(() => ({
   mockLogger: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
diff --git a/apps/dashboard/tests/server/features/discord/discord.test.ts b/apps/dashboard/tests/server/features/discord/discord.test.ts
index 821d0dc9..34a6a10f 100644
--- a/apps/dashboard/tests/server/features/discord/discord.test.ts
+++ b/apps/dashboard/tests/server/features/discord/discord.test.ts
@@ -26,11 +26,15 @@ const mockIsBotInGuild = vi.fn().mockResolvedValue(true);
 const mockGetGuildChannels = vi.fn().mockResolvedValue([]);
 const mockGetGuildRoles = vi.fn().mockResolvedValue([]);
 const mockGetGuildOwnerId = vi.fn().mockResolvedValue("owner-1");
+const mockSearchGuildMembers = vi.fn().mockResolvedValue([]);
+const mockGetGuildMembersByIds = vi.fn().mockResolvedValue([]);
 vi.mock("../../../../src/server/shared/discordApi.js", () => ({
   isBotInGuild: (...args: unknown[]) => mockIsBotInGuild(...args),
   getGuildChannels: (...args: unknown[]) => mockGetGuildChannels(...args),
   getGuildRoles: (...args: unknown[]) => mockGetGuildRoles(...args),
   getGuildOwnerId: (...args: unknown[]) => mockGetGuildOwnerId(...args),
+  searchGuildMembers: (...args: unknown[]) => mockSearchGuildMembers(...args),
+  getGuildMembersByIds: (...args: unknown[]) => mockGetGuildMembersByIds(...args),
   invalidateGuildCache: vi.fn(),
 }));
 
@@ -140,4 +144,66 @@ describe("discord routes", () => {
       expect(res.json()).toEqual([]);
     });
   });
+
+  /**
+   * Trigger filters had no member picker because the dashboard had no members
+   * endpoint at all — the only way to filter by member was to paste a raw
+   * 17-20 digit snowflake, and saved filters rendered as those digits.
+   */
+  describe("GET /api/guilds/:guildId/members", () => {
+    it("searches by name", async () => {
+      mockSearchGuildMembers.mockResolvedValueOnce([
+        { id: "1", username: "ada", displayName: "Ada", avatar: null },
+      ]);
+
+      const res = await app.inject({
+        method: "GET",
+        url: "/api/guilds/guild-1/members?q=ad",
+        cookies: { session: app.signCookie("valid") },
+      });
+
+      expect(res.statusCode).toBe(200);
+      expect(res.json()).toEqual([
+        { id: "1", username: "ada", displayName: "Ada", avatar: null },
+      ]);
+      expect(mockSearchGuildMembers).toHaveBeenCalledWith("guild-1", "ad");
+    });
+
+    it("resolves saved ids back to names", async () => {
+      mockGetGuildMembersByIds.mockResolvedValueOnce([
+        { id: "1", username: "ada", displayName: "Ada", avatar: null },
+      ]);
+
+      const res = await app.inject({
+        method: "GET",
+        url: "/api/guilds/guild-1/members?ids=1,2",
+        cookies: { session: app.signCookie("valid") },
+      });
+
+      expect(res.statusCode).toBe(200);
+      expect(mockGetGuildMembersByIds).toHaveBeenCalledWith("guild-1", ["1", "2"]);
+    });
+
+    it("returns an empty list rather than failing when Discord errors", async () => {
+      mockSearchGuildMembers.mockRejectedValueOnce(new Error("Discord down"));
+
+      const res = await app.inject({
+        method: "GET",
+        url: "/api/guilds/guild-1/members?q=ad",
+        cookies: { session: app.signCookie("valid") },
+      });
+
+      expect(res.statusCode).toBe(200);
+      expect(res.json()).toEqual([]);
+    });
+
+    it("requires authentication", async () => {
+      const res = await app.inject({
+        method: "GET",
+        url: "/api/guilds/guild-1/members?q=ad",
+      });
+      expect(res.statusCode).toBe(401);
+    });
+  });
+
 });
diff --git a/docs/superpowers/specs/2026-07-27-automation-rules-audit.md b/docs/superpowers/specs/2026-07-27-automation-rules-audit.md
new file mode 100644
index 00000000..25f6b4c9
--- /dev/null
+++ b/docs/superpowers/specs/2026-07-27-automation-rules-audit.md
@@ -0,0 +1,164 @@
+# Automation / Rules — UX & correctness audit
+
+**Date:** 2026-07-27
+**Branch:** `worktree-fix-automation-rules-ux`
+**Scope:** the whole automation surface — dashboard canvas editor, rules list, actions API, `packages/systems/src/actions`, and the bot-side executor/eventBridge/registry.
+**Method:** five parallel auditors over independent dimensions, each finding then put through an adversarial refutation pass. 62 raised, 47 confirmed, 5 refuted, 10 unverified (the verifier hit a session limit).
+
+## Summary
+
+The automation feature is architecturally sound and further along than it looks: the bot really does execute the v2 step graph ([`executor.ts:274`](../../apps/bot/src/features/automation/system/executor.ts#L274)), with iteration caps, delay caps, per-(guild, event) rate limiting, and template-injection defences that are pinned by tests. The canvas, context menu, keyboard nav and variable-field editor are all real, working work.
+
+The problem is that **almost nothing that goes wrong is visible to the user.** The same failure shape recurs at every layer: a misconfiguration is accepted without complaint, does nothing at runtime, and is then recorded as a *success*. A rule with no channel saves green, never fires, and reports 100% success. A trigger filter whose data the event does not carry is skipped entirely, so an "exclude @Staff" rule announces staff bans anyway. `addRole` on a reaction trigger silently no-ops. `hasRole` conditions always take the else-branch. In every one of these the dashboard actively tells the user everything is fine.
+
+**The single most important fix is to stop lying about success** — make missing configuration an error at save time, a thrown failure at runtime, and a visible state in the rule list. Everything else in this document is secondary to that.
+
+The three reported problems are all real and all have narrow, well-understood root causes. Two of them (A and C) are instances of the "silent acceptance" pattern above; the third (B) is a partial wiring gap rather than the total absence the report suggested.
+
+## The three reported problems
+
+### (A) Action nodes don't force required fields before save
+
+**Root cause.** [`workflow-validation.ts:213-217`](../../apps/dashboard/src/client/features/automation/lib/workflow-validation.ts#L213-L217) reports a missing required field at `level: "warning"`, and [`workflow-validation.ts:61`](../../apps/dashboard/src/client/features/automation/lib/workflow-validation.ts#L61) computes `valid` from **errors only**. Save is disabled on `!validation.valid`, so warnings never block it. The server does not compensate: [`routes.ts:85`](../../apps/dashboard/src/server/features/actions/routes.ts#L85) checks only that `action.type` is known plus the webhook URL scheme — every other required field is unchecked, so the Undo-restore and Duplicate paths in `rules.tsx` can re-POST a dead rule too.
+
+**What the user sees.** Pick "Send Message", skip the channel, click Save. The button is enabled, the toolbar shows an amber "1 issue" chip rather than a red one, a green "Rule created" toast fires, and the rule sits in the list looking healthy. It then never does anything, forever. Every action type has such a configuration: `sendMessage` (channelId, message), `sendEmbed` (channelId), `sendDM` (message), `addRole`/`removeRole` (roleId), `logToChannel` (channelId), `setNickname` (nickname), `createThread` (channelId, threadName), `addReaction` (emoji). Five of the six preset templates ship in exactly this state — the onboarding path is the fastest way to build a broken rule.
+
+**Fix.** Promote the required-field branch to `level: "error"` (keeping genuinely advisory items — `conditionValueEmpty`, `delayNotConnected`, `stepUnreachable` — as warnings so the split stays meaningful); enforce the same `ACTION_TYPE_FIELDS` contract server-side in `validateRuleBody`; and surface it per-field in `ActionFields.tsx` with `aria-invalid` + an inline message instead of only a decorative asterisk. Then make the runtime honest: a missing required field must `throw` so it is logged `success: false`, not `return` silently.
+
+### (B) Per-trigger variables don't reach the action's completion
+
+**Root cause.** The autocomplete path *is* wired — `buildAutomationVariables(constants, eventType)` at [`NodeDetailPanel.tsx:317`](../../apps/dashboard/src/client/features/automation/workflow/NodeDetailPanel.tsx#L317) feeds the trigger-scoped list into `VariableEditor`. Three real gaps sit around it:
+
+1. The action panel's **Variables tab** ignores the trigger entirely: [`NodeDetailPanel.tsx:432-437`](../../apps/dashboard/src/client/features/automation/workflow/NodeDetailPanel.tsx#L432-L437) renders `Object.keys(constants.templateVariables)` — all 27 tokens — while the trigger panel's tab renders the scoped set. So the reference list contradicts the autocomplete, and contradicts the editor's own unknown-token validator.
+2. The **step-mode action editor has no Variables tab and no message preview at all** ([`NodeDetailPanel.tsx:544-605`](../../apps/dashboard/src/client/features/automation/workflow/NodeDetailPanel.tsx#L544-L605)). Adding one condition or delay converts the rule to step mode and strips both from every action in it.
+3. ~~Some fields never get the editor.~~ **Withdrawn on implementation.** `ActionFields.tsx:19-27` does gate the `VariableEditor` on a hardcoded `VARIABLE_FIELD_KEYS` set, but enumerating every `text`/`textarea` field in `ACTION_TYPE_FIELDS` shows the set is already complete: the only three outside it are `webhook.url`, `webhook.headers` (JSON) and `emoji` — none of which should accept templates. No change needed.
+
+Underneath, `EVENT_TYPE_VARIABLES` also **over-promises**: it advertises `{channel*}` on member/ban/role events and `{user*}` on channel events that `eventBridge` never populates, so the preview renders `#general`/`@Ada` where the bot will post `Unknown Channel`/`Unknown User`.
+
+**What the user sees.** Autocomplete works, but the Variables reference beside it lists tokens the trigger cannot provide; add a condition and both the reference and the preview vanish; and some of the tokens that *are* offered render as `Unknown` at runtime.
+
+**Fix.** Pass the scoped list to the action Variables tab, give `StepPanel` the same tabs/preview as `ActionPanel`, drive `VARIABLE_FIELD_KEYS` off the field descriptors rather than a hardcoded set, and prune `EVENT_TYPE_VARIABLES` down to what `eventBridge` actually populates (or populate what it promises).
+
+### (C) Trigger filters aren't convenient
+
+This one is worse than "inconvenient" — the filters are **unreliable**, and that outranks the ergonomics.
+
+**Root cause — correctness.** [`executor.ts:54-79`](../../apps/bot/src/features/automation/system/executor.ts#L54-L79) guards every filter on the presence of its datum: `if (conditions.excludeRoleIds?.length && context.member)`. When the event context lacks the field the filter is **skipped, not failed**. `buildBanContext` never sets `member`, so "exclude @Staff" on a `memberBanned` rule announces staff bans anyway. Same for role filters on `reactionAdded` and `memberLeave`. Worse, on `threadCreated`/`channelCreated` the context channel *is* the new thread, so an include-channel filter can never match and the rule silently never fires.
+
+**Root cause — ergonomics.** Users add member filters by pasting raw 17–20 digit snowflakes ([`ConditionsEditor.tsx:69-128`](../../apps/dashboard/src/client/features/automation/components/ConditionsEditor.tsx#L69-L128)) and saved users render as bare digits — there is no member-search endpoint anywhere in the dashboard to build a picker on. The channel picker cannot offer announcement, forum, stage or thread channels. All six filters are offered for every event type including combinations the runtime can never evaluate. Include/exclude reuse identical labels and the four comboboxes have no programmatic label, so a screen-reader user cannot tell them apart. And active filters are invisible outside the open panel — not on the canvas node, not in the rule list.
+
+**Fix.** Pick one explicit policy — a configured filter whose datum is missing should **fail closed** (rule does not fire) rather than be dropped — and populate the contexts where the data is obtainable. Then make the editor event-aware so it never offers a filter the runtime cannot evaluate for the selected trigger, and add a filter summary to the trigger node.
+
+## Other confirmed defects
+
+
+### High (12)
+
+| # | Defect | Location | Impact |
+|---|---|---|---|
+| 1 | Actions with a missing required field silently no-op at runtime AND are recorded as successful executions | `bot/features/automation/system/executor.ts:295` | A moderator's "auto-role on join" rule never assigns the role |
+| 2 | Server gate validates only action.type and webhook URL — every other required field is unchecked | `~/server/features/actions/routes.ts:85` | Even after the client-side warning/error split is fixed, the real gate still accepts a dead rule |
+| 3 | Five of six preset rule templates produce a rule with a required field blank | `~/client/routes/guild/$guildId/rules.tsx:68` | The product's own onboarding path is the fastest way to create a broken rule |
+| 4 | Trigger filters silently no-op when the event context lacks the field — exclude filters especially, so rules fire on users/channels they were configured to skip | `bot/features/automation/system/executor.ts:60` | An admin builds a `memberBanned` rule that DMs a moderator log and adds `Exclude → Roles: @Staff` so staff bans are not announced |
+| 5 | Include-channel filter can never match threadCreated/channelCreated (the context channel is the new thread/channel), and the picker cannot offer announcement, forum, stage or thread channels at all | `bot/features/automation/system/eventBridge.ts:379` | A user creates a `threadCreated` rule and adds `Include → Channels: #support` intending "only threads under #support" |
+| 6 | hasRole / notHasRole always false unless the unrelated condition field happens to be populated | `bot/features/automation/system/executor.ts:117` | User builds the canonical flow: on member join, IF member hasRole @Verified then welcome, ELSE send verification DM |
+| 7 | addRole / removeRole silently do nothing on any event whose context has no member, and are logged as success | `bot/features/automation/system/registry.ts:85` | The classic reaction-role automation - 'when someone reacts with a check mark, give them @Member' - saves cleanly, shows a green node, and does absolutely nothing at runtime |
+| 8 | reactionAdded / reactionRemoved / messageDeleted triggers never fire for uncached messages because the client enables no Partials | `bot/shared/client/ExtendedClient.ts:9` | An admin sets up 'when someone reacts to this rules message, give them a role' on a pinned message posted last month, or 'log every deleted message' |
+| 9 | The /actions bot command silently downgrades a canvas-built rule to a flat action list, destroying conditions, delays and branches | `bot/features/general/commands/actions.ts:761` | A user spends time building a branching workflow in the canvas, then runs /actions edit rule:welcome message:hi (or add-action) in Discord |
+| 10 | Missing required action fields are only "warnings", so Save stays enabled and a rule that can never execute is persisted | `~/client/features/automation/lib/workflow-validation.ts:213` | User picks trigger "Member Join", picks action "Send Message", never opens the Channel picker, sees the toolbar say "1 issue" in amber, and Save is fully enabled |
+| 11 | Changing an action's type discards every field the user already filled in, with no warning and no undo | `~/client/features/automation/workflow/NodeDetailPanel.tsx:320` | User composes a 400-character welcome message under "Send Message", realises it should be a DM, switches the type to "Send DM" — both action types have a `message` field, but the message … |
+| 12 | Escape typed inside the rule-name or any other input closes the entire editor instead of the field | `~/client/features/automation/workflow/useWorkflowKeyboard.ts:55` | User types a rule name, decides the text is wrong, presses Escape out of habit to revert the field, and the whole full-screen editor closes |
+
+### Medium (19)
+
+| # | Defect | Location | Impact |
+|---|---|---|---|
+| 1 | The webhook Headers field writes a raw string into a field typed as a record, making the rule unsavable with an untranslated Zod message | `~/client/features/automation/components/ActionFields.tsx:155` | A user configuring sendWebhook types the exact JSON the placeholder shows them, clicks Save, and gets a red banner reading "Expected object, received string" — English-only regardless of … |
+| 2 | The server validates body.actions but persists body.steps unchecked — and the bot executes steps in preference to actions | `~/server/features/actions/routes.ts:106` | The declared server contract does not cover the code path that actually executes |
+| 3 | Step-mode action editor has no Variables tab and no message preview at all — adding a single condition or delay strips both from every action in the rule | `~/client/features/automation/workflow/NodeDetailPanel.tsx:560` | User builds a Send Message rule, sees the variable reference and the live Discord preview, then adds one condition to branch on channel |
+| 4 | Before a trigger is picked, every variable typed into an action is flagged "Unknown variable" and autocomplete never opens | `~/client/shared/ui/variable-field/automationVariables.ts:40` | A first-time user drags in an action before choosing a trigger (nothing stops them), types `{user}` in the Message field, and the field turns red: "Unknown variable {user}" — for the sing… |
+| 5 | EVENT_TYPE_VARIABLES promises {channel*} on member/ban/role events and {user*} on channel events, but the bot never populates them — the preview shows #general/@Ada while the bot posts "Unknown Channel"/"Unknown User" | `bot/features/automation/system/eventBridge.ts:32` | User writes a memberJoin welcome message "Welcome {user} to {channel}!" |
+| 6 | ConditionsEditor offers all six filters for every event type, including combinations the bot can never evaluate, and nothing validates them | `~/client/features/automation/workflow/NodeDetailPanel.tsx:285` | A user configuring a `channelCreated` rule sees Include → Users and Include → Roles pickers, picks "only when @Admin creates a channel", saves, sees no warning anywhere, and the rule fire… |
+| 7 | User filters require pasting raw 17-20 digit snowflakes and render saved users as bare digits — there is no member search endpoint anywhere in the dashboard | `~/client/features/automation/components/ConditionsEditor.tsx:123` | To exclude one troublesome member from an automation, an admin must leave the dashboard, enable Discord developer mode, right-click the user, copy the ID, and paste it back |
+| 8 | The four channel/role filter comboboxes have no programmatic label, and include vs exclude are indistinguishable to a screen reader | `~/client/shared/ui/discord-multi-select.tsx:108` | A screen-reader user tabbing the Filters tab hears: "Add channel..., button / Add role..., button / Users, edit / Add user ID, button / Exclude channel..., button / Exclude role..., butto… |
+| 9 | Every event/action type label and description in the automation UI — including the rules-list event filter — is hardcoded English served from the API, in an app with 48 locales | `~/client/routes/guild/$guildId/rules.tsx:428` | An Arabic or Japanese admin opens Automation: the page chrome, filter placeholders and buttons are localised, but the event-type filter dropdown reads "Member Join / Message Deleted / Boo… |
+| 10 | Trigger include/exclude filters are silently skipped when the event context lacks the value (fail open) | `bot/features/automation/system/executor.ts:54` | An admin restricts a reaction rule to 'only members with @Staff' or 'exclude @Muted' |
+| 11 | ActionLog records success=true for actions that never ran, swallowed failures, and unknown action types, so the dashboard success rate is fiction | `bot/features/automation/system/executor.ts:189` | A user whose welcome DM is blocked by everyone's privacy settings, or whose rule has an unfilled channel field (the editor only warns, so it saves), sees 'Success rate 100%' on the rules … |
+| 12 | sendWebhook SSRF: the https + private-IP check is bypassed by a redirect, and the response body is read unbounded | `bot/features/automation/system/registry.ts:226` | Any guild admin (or anyone who compromises one dashboard session) can point a webhook action at their own https endpoint that redirects to the cloud metadata service or an internal host, … |
+| 13 | EVENT_TYPE_VARIABLES advertises variables the event context never populates; templates render Unknown / 0 instead | `systems/actions/constants.ts:224` | The autocomplete for a Member Join trigger offers {channel} and {channel.name}; the user inserts them, the Discord preview renders them, and the live message posts the literal text 'Unkno… |
+| 14 | A delay step blocks every lower-priority rule for that event, is lost on restart, and is silently skipped at the concurrency cap | `bot/features/automation/system/executor.ts:235` | A user drags a 'wait 5 minutes then send a reminder' node into a high-priority join rule; their other join rules (autorole, log) also stop running for five minutes per join |
+| 15 | Rate limiting silently aborts rules mid-workflow with no user-visible signal | `bot/features/automation/system/executor.ts:184` | On a busy server a messageCreated rule stops firing after 60 actions in a minute and users report 'the bot randomly ignores some messages' |
+| 16 | Deleting the last step drops the canvas back to linear mode and resurrects the stale pre-conversion actions array | `~/client/features/automation/workflow/useWorkflowNodes.ts:409` | User converts a 3-action rule to a workflow, reworks it into 2 steps, then deletes those 2 steps to start over |
+| 17 | Editing an existing rule autosaves a draft that is never read back, and closing the editor discards the edits with no confirmation and no beforeunload guard | `~/client/features/automation/workflow/WorkflowEditor.tsx:109` | User opens an existing rule, spends five minutes rewriting the embed and rewiring two steps, then hits Escape or the browser Back button |
+| 18 | Step mode enforces no action/step/condition ceiling, so the server rejects the finished rule with a raw untranslated English error | `~/client/features/automation/workflow/WorkflowEditor.tsx:632` | User builds a 6-action / 4-condition workflow with the buttons the UI happily keeps enabled, the toolbar reports "Ready", then Save fails with the literal string "Max 5 actions" — in Engl… |
+| 19 | The only aggregate validation explanation is a hover tooltip on a non-focusable div, and the disabled Save button gives no accessible reason or way to reach the bad node | `~/client/features/automation/workflow/WorkflowEditor.tsx:659` | A keyboard or screen-reader user sees a permanently greyed Save button and is never told why |
+
+### Low (14)
+
+| # | Defect | Location | Impact |
+|---|---|---|---|
+| 1 | ActionFields has no inline error affordance — required fields get only a decorative asterisk, no aria-invalid, no message, no touched state | `~/client/features/automation/components/ActionFields.tsx:79` | A screen-reader user tabs into the Channel picker for a Send Message action |
+| 2 | RULE_NAME_REGEX guards the bot command but not the dashboard API, so its stated injection protection is bypassable | `~/server/features/actions/routes.ts:59` | A dashboard admin names a rule `@everyone` or `<@&1234>` |
+| 3 | Creating a rule with a duplicate name hits an unhandled Prisma P2002 and returns a 500 with a generic client message | `~/server/features/actions/routes.ts:249` | An admin uses the "Welcome Message" template twice (both drafts hard-code `name: t("templates.welcomeMessageName")` at rules.tsx:52), or simply retypes a name they already used |
+| 4 | No test anywhere asserts required-field enforcement, and the one server test that touches it asserts the broken behaviour | `apps/dashboard/tests/server/features/actions/actions.test.ts:236` | Any fix to the required-field gate can be silently reverted, and in fact the current test suite would FAIL the correct behaviour — a maintainer who fixes routes.ts to reject an action wit… |
+| 5 | Nothing validates action templates against the selected trigger at rule level — a rule full of tokens the trigger cannot provide saves cleanly, and changing the trigger silently invalidates every template | `~/client/features/automation/lib/workflow-validation.ts:206` | User writes a messageCreated rule using {message.content}, later switches the trigger to memberJoin from the trigger panel |
+| 6 | DiscordMultiSelect — the component that renders four of the six trigger filters — ships hardcoded English strings and never calls useTranslation | `~/client/shared/ui/discord-multi-select.tsx:104` | In any non-English locale, opening Include → Channels shows a popover whose search box says "Search...", whose empty state says "No channels available", and whose trigger reads "3 selecte… |
+| 7 | Active trigger filters are invisible outside the open detail panel — neither the canvas trigger node nor the rule list shows that a rule is filtered | `~/client/features/automation/workflow/nodes/TriggerNode.tsx:25` | A rule stops firing |
+| 8 | The rules-list event filter keeps filtering after its option disappears, leaving a control with no readable value and an empty list | `~/client/routes/guild/$guildId/rules.tsx:206` | Admin filters to "Member Join" (2 rules), deletes both |
+| 9 | The server stores trigger conditions verbatim — no snowflake, guild-ownership or key validation — and deleted channels/roles then render as bare IDs | `~/server/features/actions/routes.ts:260` | A moderator deletes #welcome in Discord |
+| 10 | Include semantics (OR within a group, AND across groups, empty = match all) are never stated, and the one explanatory sentence is ambiguous | `i18n/locales/en/rules.json:146` | An admin adds Include → Roles: @Member and @Verified expecting "members who have BOTH roles" (the copy says "matches all include filters"), but the bot fires for anyone with EITHER |
+| 11 | The canvas allows a loop and the executor has no cycle detection - looped actions run up to 20 times per event | `bot/features/automation/system/executor.ts:174` | A user connects the last node back to an earlier one (easy to do by accident when re-routing an edge) |
+| 12 | The API stores step contents unvalidated; a condition step without a value throws inside the one code path with no try/catch, aborting all remaining rules | `~/server/features/actions/routes.ts:106` | A hand-built or third-party API call (the endpoints are documented via withDocs), or any future client bug, persists a condition step with no value or an unknown operator |
+| 13 | The entire v2 step-graph execution path is untested | `apps/bot/tests/features/automation/system/executor.test.ts:45` | Every defect above in condition evaluation and step traversal shipped undetected, and the project's own CLAUDE.md rule ('Every Feature Must Include Tests  |
+| 14 | Trigger filters are invisible everywhere except inside the trigger panel — not on the canvas, not in the rule list | `~/client/features/automation/workflow/useWorkflowNodes.ts:23` | User restricts a rule to one channel, saves, and later wonders why it never fires elsewhere |
+
+### Unverified (10) — the adversarial pass hit the session limit before these ran
+
+| Defect | Location | Note |
+|---|---|---|
+| The template gallery only exists while the guild has zero rules, and the editor itself offers no onboarding | `~/client/routes/guild/$guildId/rules.tsx:520` | medium / ux |
+| Condition and Delay nodes never render their warning validation state, so their issues have no anchor on the canvas | `~/client/features/automation/workflow/nodes/ConditionNode.tsx:31` | medium / validation |
+| The action panel's Variables tab lists every template variable regardless of the trigger, and step-mode action panels have no Variables tab at all | `~/client/features/automation/workflow/NodeDetailPanel.tsx:434` | medium / parity |
+| An empty draft is written 500 ms after the editor opens, so the next "Create Rule" greets the user with a bogus "Draft restored" banner | `~/client/features/automation/workflow/WorkflowEditor.tsx:182` | medium / ux |
+| Deleting two or more selected action nodes at once removes the wrong actions because the indices shift between removals | `~/client/features/automation/workflow/WorkflowEditor.tsx:229` | medium / correctness |
+| The rule list has no way to show that a saved rule is misconfigured — its only "not configured" marker is unreachable dead code | `~/client/features/automation/components/RuleList.tsx:269` | medium / ux |
+| The full-screen editor is portalled over the app without focus containment, so Tab reaches the sidebar behind it and navigating away destroys unsaved work | `~/client/features/automation/workflow/WorkflowEditor.tsx:894` | medium / a11y |
+| Every trigger name, action name, description, field label and placeholder is hardcoded English served from the API, in a 48-locale dashboard | `systems/actions/constants.ts:18` | medium / i18n |
+| Trigger filters clear all six lists on a single unconfirmed click, and member filters require pasting raw snowflake IDs while channels and roles get pickers | `~/client/features/automation/components/ConditionsEditor.tsx:287` | medium / ux |
+| The rule list step counter interpolates `count` without plural categories, so it reads "+1 steps" in English and is ungrammatical in every plural-rich locale | `~/client/features/automation/components/RuleList.tsx:312` | low / i18n |
+## Refuted — deliberately not fixed
+
+Five findings did not survive the adversarial pass and are recorded here so they are not re-raised:
+
+- *"Automation reimplements the variable picker instead of reusing VariableBrowser"* — false premise; the shared primitive is already used for insertion.
+- *"`buildAutomationVariables` is unmemoized, breaking downstream memos"* — mechanically true, no reachable impact (the array is small and the claimed keystroke cost does not occur).
+- *"Rules-list filters are component state and reset on navigation"* — accurate reading of the code, but the load-bearing user scenario is unreachable.
+- *"The rules-list event filter should be a SearchableSelect"* — the code quotes are right, the severity was not; folded into the i18n item instead.
+- *"Adding a Condition or Delay permanently deletes unconfigured actions"* — `convertToStepMode` does not lose data the way claimed.
+
+## Suggested fix order
+
+Each item is one commit, with the tests it needs. FluxCore requires tests for every change.
+
+1. **Make required fields block the save.** `workflow-validation.ts` warning→error; server-side `ACTION_TYPE_FIELDS` enforcement in `validateRuleBody`; inline `aria-invalid` + message in `ActionFields`. Closes **(A)**.
+   *Tests:* per-action-type cases in `workflow-validation.test.ts`; server rejection cases in `tests/server/features/actions/actions.test.ts` (and fix the existing test that asserts the broken behaviour).
+2. **Stop reporting phantom successes.** Executors throw on missing config instead of returning; `executor.ts` unknown-action branch must not fall through to the success log; resolve the member in `addRole`/`removeRole`.
+   *Tests:* `apps/bot/tests/features/automation/system/executor.test.ts` — assert `success: false` and the error text.
+3. **Fix filter semantics (fail closed) and populate missing contexts.** `matchesConditions` + `buildBanContext`/`buildReactionContext`. Closes half of **(C)**.
+   *Tests:* executor unit tests per event/filter combination.
+4. **Make the conditions editor event-aware** and add a filter summary to the trigger node. Closes the rest of **(C)**.
+   *Tests:* `ConditionsEditor` component tests; `useWorkflowNodes.test.ts` for the summary.
+5. **Scope the action Variables tab to the trigger; give StepPanel tabs + preview; derive `VARIABLE_FIELD_KEYS` from descriptors.** Closes **(B)**.
+   *Tests:* `NodeDetailPanel` component tests asserting the scoped token set in both modes.
+6. **Reconcile `EVENT_TYPE_VARIABLES` with what `eventBridge` populates.** Finishes **(B)**.
+   *Tests:* a matrix test in `packages/systems/tests/` pinning promised-vs-populated per event type.
+7. **i18n the automation vocabulary.** Move event/action labels, descriptions, field labels and placeholders out of `packages/systems/src/actions/constants.ts` into `rules.json` keys resolved client-side; translate across all 48 locales.
+   *Tests:* key-parity test.
+8. **Editor data-loss fixes.** Preserve shared fields on action-type change; scope Escape to the focused control; unsaved-changes guard on close; fix the multi-node delete index bug.
+   *Tests:* `WorkflowEditor.test.tsx`.
+9. **Webhook headers JSON field**, SSRF redirect hardening, and the remaining low-severity items.
+
+## Not in scope of the reported complaints, but worth flagging
+
+- [`ExtendedClient.ts:9`](../../apps/bot/src/shared/client/ExtendedClient.ts#L9) enables **no Partials**, so `reactionAdded`/`reactionRemoved`/`messageDeleted` triggers never fire for messages the bot has not cached since its last restart. Reaction-role automations on an old pinned message simply never work. This is a bot-wide fix, not an automation-only one.
+- [`actions.ts:761`](../../apps/bot/src/features/general/commands/actions.ts#L761) — the `/actions` slash command silently downgrades a canvas-built workflow to a flat action list, destroying conditions, delays and branches.
diff --git a/packages/i18n/src/locales/af/common.json b/packages/i18n/src/locales/af/common.json
index 4a5b0b0e..9ed78497 100644
--- a/packages/i18n/src/locales/af/common.json
+++ b/packages/i18n/src/locales/af/common.json
@@ -90,7 +90,9 @@
     "saving": "Stoor...",
     "saveSettings": "Stoor Instellings",
     "previous": "Vorige",
-    "next": "Volgende"
+    "next": "Volgende",
+    "invalidJson": "Nie geldige JSON nie — 'n objek van tekswaardes word verwag",
+    "fieldRequired": "{{field}} is verpligtend"
   },
   "pagination": {
     "previous": "Vorige",
diff --git a/packages/i18n/src/locales/af/rules.json b/packages/i18n/src/locales/af/rules.json
index 2afd1b84..4041c122 100644
--- a/packages/i18n/src/locales/af/rules.json
+++ b/packages/i18n/src/locales/af/rules.json
@@ -146,7 +146,18 @@
     "include": "Sluit In (witlys)",
     "exclude": "Sluit Uit (swartelys)",
     "clearAll": "Maak alle voorwaardes skoon",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "Verwyder {{label}}",
+    "collapse": "Vou voorwaardes in",
+    "userIdInvalid": "Voer 'n geldige Discord-gebruiker-ID in (17–20 syfers)",
+    "addUserId": "Voeg gebruiker-ID by",
+    "includeChannels": "Slegs in hierdie kanale",
+    "includeRoles": "Slegs lede met hierdie rolle",
+    "includeUsers": "Slegs hierdie lede",
+    "excludeChannels": "Nooit in hierdie kanale nie",
+    "excludeRoles": "Nooit lede met hierdie rolle nie",
+    "excludeUsers": "Nooit hierdie lede nie",
+    "unsupportedWarning": "Hierdie sneller kan nie hierdie filters ({{filters}}) evalueer nie, dus sal die reël nooit afgaan solank hulle gestel is nie.",
+    "removeUnsupported": "Verwyder filters wat nie kan geld nie"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "Onopgeslane veranderinge weggooi?",
+    "discardChangesDescription": "Hierdie reël het veranderinge wat nie gestoor is nie. As jy die redigeerder toemaak, gaan hulle verlore.",
+    "discardChanges": "Gooi veranderinge weg",
+    "draftRestored": "Konsep herstel uit 'n vorige sessie",
+    "discardDraftAction": "Gooi konsep weg",
+    "discardTitle": "Veranderinge weggooi?",
+    "discardDescription": "Jy het onopgeslane veranderinge. Jou konsep word plaaslik gestoor, maar jy verlaat die redigeerder.",
+    "discardConfirm": "Gooi weg en maak toe"
   },
   "panel": {
     "trigger": "Trigger Settings",
@@ -322,5 +341,83 @@
     "stepUnreachable": "Step \"{{id}}\" is not reachable from the trigger",
     "noActionType": "{{label}}: no action type selected",
     "fieldRequired": "{{label}}: {{field}} is required"
+  },
+  "eventTypes": {
+    "memberJoin": {
+      "label": "Lid sluit aan",
+      "description": "Wanneer 'n nuwe lid by die bediener aansluit"
+    },
+    "memberLeave": {
+      "label": "Lid vertrek",
+      "description": "Wanneer 'n lid die bediener verlaat"
+    },
+    "memberBanned": {
+      "label": "Lid verban",
+      "description": "Wanneer 'n lid verban word"
+    },
+    "memberUnbanned": {
+      "label": "Lid ontban",
+      "description": "Wanneer 'n lid se verbanning opgehef word"
+    },
+    "messageDeleted": {
+      "label": "Boodskap verwyder",
+      "description": "Wanneer 'n boodskap verwyder word"
+    },
+    "roleAdded": {
+      "label": "Rol bygevoeg",
+      "description": "Wanneer 'n rol by 'n lid gevoeg word"
+    },
+    "roleRemoved": {
+      "label": "Rol verwyder",
+      "description": "Wanneer 'n rol van 'n lid verwyder word"
+    },
+    "channelCreated": {
+      "label": "Kanaal geskep",
+      "description": "Wanneer 'n nuwe kanaal geskep word"
+    },
+    "channelDeleted": {
+      "label": "Kanaal verwyder",
+      "description": "Wanneer 'n kanaal verwyder word"
+    },
+    "voiceJoin": {
+      "label": "Sluit by stem aan",
+      "description": "Wanneer 'n lid by 'n stemkanaal aansluit"
+    },
+    "voiceLeave": {
+      "label": "Verlaat stem",
+      "description": "Wanneer 'n lid 'n stemkanaal verlaat"
+    },
+    "messageCreated": {
+      "label": "Boodskap gestuur",
+      "description": "Wanneer 'n boodskap in 'n kanaal gestuur word"
+    },
+    "reactionAdded": {
+      "label": "Reaksie bygevoeg",
+      "description": "Wanneer 'n reaksie by 'n boodskap gevoeg word"
+    },
+    "reactionRemoved": {
+      "label": "Reaksie verwyder",
+      "description": "Wanneer 'n reaksie van 'n boodskap verwyder word"
+    },
+    "nicknameChanged": {
+      "label": "Bynaam verander",
+      "description": "Wanneer 'n lid se bynaam verander word"
+    },
+    "memberTimeout": {
+      "label": "Lid uitgetel",
+      "description": "Wanneer 'n lid uitgetel word"
+    },
+    "threadCreated": {
+      "label": "Draad geskep",
+      "description": "Wanneer 'n nuwe draad geskep word"
+    },
+    "boostStart": {
+      "label": "Versterking begin",
+      "description": "Wanneer 'n lid die bediener begin versterk"
+    },
+    "boostEnd": {
+      "label": "Versterking eindig",
+      "description": "Wanneer 'n lid ophou om die bediener te versterk"
+    }
   }
 }
diff --git a/packages/i18n/src/locales/ar/common.json b/packages/i18n/src/locales/ar/common.json
index 60f030ed..36790928 100644
--- a/packages/i18n/src/locales/ar/common.json
+++ b/packages/i18n/src/locales/ar/common.json
@@ -90,7 +90,9 @@
     "saving": "جارٍ الحفظ...",
     "saveSettings": "حفظ الإعدادات",
     "previous": "السابق",
-    "next": "التالي"
+    "next": "التالي",
+    "invalidJson": "ليست JSON صالحة — المتوقع كائن من القيم النصية",
+    "fieldRequired": "{{field}} مطلوب"
   },
   "pagination": {
     "previous": "السابق",
diff --git a/packages/i18n/src/locales/ar/rules.json b/packages/i18n/src/locales/ar/rules.json
index c5efa0b8..27ce8a1e 100644
--- a/packages/i18n/src/locales/ar/rules.json
+++ b/packages/i18n/src/locales/ar/rules.json
@@ -146,7 +146,18 @@
     "include": "تضمين (قائمة بيضاء)",
     "exclude": "استثناء (قائمة سوداء)",
     "clearAll": "مسح جميع الشروط",
-    "removeItem": "إزالة {{label}}"
+    "removeItem": "إزالة {{label}}",
+    "collapse": "طيّ الشروط",
+    "userIdInvalid": "أدخل معرّف مستخدم Discord صالحًا (17–20 رقمًا)",
+    "addUserId": "إضافة معرّف مستخدم",
+    "includeChannels": "في هذه القنوات فقط",
+    "includeRoles": "الأعضاء الحاصلون على هذه الأدوار فقط",
+    "includeUsers": "هؤلاء الأعضاء فقط",
+    "excludeChannels": "لا في هذه القنوات أبدًا",
+    "excludeRoles": "لا الأعضاء الحاصلون على هذه الأدوار أبدًا",
+    "excludeUsers": "لا هؤلاء الأعضاء أبدًا",
+    "unsupportedWarning": "لا يستطيع هذا المشغّل تقييم هذه المرشّحات ({{filters}})، لذا لن تُنفَّذ القاعدة ما دامت مضبوطة.",
+    "removeUnsupported": "إزالة المرشّحات التي لا يمكن تطبيقها"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "ملاءمة العرض"
     },
     "issues_one": "{{count}} مشكلة",
-    "issues_other": "{{count}} مشكلة"
+    "issues_other": "{{count}} مشكلة",
+    "discardChangesTitle": "تجاهل التغييرات غير المحفوظة؟",
+    "discardChangesDescription": "تحتوي هذه القاعدة على تعديلات لم تُحفظ. إغلاق المحرر سيؤدي إلى فقدانها.",
+    "discardChanges": "تجاهل التغييرات",
+    "draftRestored": "تمت استعادة مسودة من جلسة سابقة",
+    "discardDraftAction": "تجاهل المسودة",
+    "discardTitle": "تجاهل التغييرات؟",
+    "discardDescription": "لديك تغييرات غير محفوظة. تُحفظ مسودتك محليًا، لكنك ستغادر المحرر.",
+    "discardConfirm": "تجاهل وإغلاق"
   },
   "panel": {
     "trigger": "إعدادات المُشغِّل",
@@ -322,5 +341,83 @@
     "stepUnreachable": "الخطوة \"{{id}}\" غير قابلة للوصول من المُشغِّل",
     "noActionType": "{{label}}: لم يتم اختيار نوع إجراء",
     "fieldRequired": "{{label}}: {{field}} مطلوب"
+  },
+  "eventTypes": {
+    "memberJoin": {
+      "label": "انضمام عضو",
+      "description": "عند انضمام عضو جديد إلى الخادم"
+    },
+    "memberLeave": {
+      "label": "مغادرة عضو",
+      "description": "عند مغادرة عضو للخادم"
+    },
+    "memberBanned": {
+      "label": "حظر عضو",
+      "description": "عند حظر عضو"
+    },
+    "memberUnbanned": {
+      "label": "رفع حظر عضو",
+      "description": "عند رفع الحظر عن عضو"
+    },
+    "messageDeleted": {
+      "label": "حذف رسالة",
+      "description": "عند حذف رسالة"
+    },
+    "roleAdded": {
+      "label": "إضافة دور",
+      "description": "عند إضافة دور إلى عضو"
+    },
+    "roleRemoved": {
+      "label": "إزالة دور",
+      "description": "عند إزالة دور من عضو"
+    },
+    "channelCreated": {
+      "label": "إنشاء قناة",
+      "description": "عند إنشاء قناة جديدة"
+    },
+    "channelDeleted": {
+      "label": "حذف قناة",
+      "description": "عند حذف قناة"
+    },
+    "voiceJoin": {
+      "label": "دخول قناة صوتية",
+      "description": "عند دخول عضو إلى قناة صوتية"
+    },
+    "voiceLeave": {
+      "label": "مغادرة قناة صوتية",
+      "description": "عند مغادرة عضو لقناة صوتية"
+    },
+    "messageCreated": {
+      "label": "إرسال رسالة",
+      "description": "عند إرسال رسالة في قناة"
+    },
+    "reactionAdded": {
+      "label": "إضافة تفاعل",
+      "description": "عند إضافة تفاعل إلى رسالة"
+    },
+    "reactionRemoved": {
+      "label": "إزالة تفاعل",
+      "description": "عند إزالة تفاعل من رسالة"
+    },
+    "nicknameChanged": {
+      "label": "تغيير الاسم المستعار",
+      "description": "عند تغيير الاسم المستعار لعضو"
+    },
+    "memberTimeout": {
+      "label": "إسكات عضو",
+      "description": "عند إسكات عضو مؤقتًا"
+    },
+    "threadCreated": {
+      "label": "إنشاء موضوع",
+      "description": "عند إنشاء موضوع جديد"
+    },
+    "boostStart": {
+      "label": "بدء الدعم",
+      "description": "عند بدء عضو في دعم الخادم"
+    },
+    "boostEnd": {
+      "label": "انتهاء الدعم",
+      "description": "عند توقف عضو عن دعم الخادم"
+    }
   }
 }
diff --git a/packages/i18n/src/locales/bg/common.json b/packages/i18n/src/locales/bg/common.json
index aca506d9..21fc2663 100644
--- a/packages/i18n/src/locales/bg/common.json
+++ b/packages/i18n/src/locales/bg/common.json
@@ -90,7 +90,9 @@
     "saving": "Запазване...",
     "saveSettings": "Запази настройките",
     "previous": "Предишна",
-    "next": "Следваща"
+    "next": "Следваща",
+    "invalidJson": "Невалиден JSON — очаква се обект с текстови стойности",
+    "fieldRequired": "{{field}} е задължително"
   },
   "pagination": {
     "previous": "Предишна",
diff --git a/packages/i18n/src/locales/bg/rules.json b/packages/i18n/src/locales/bg/rules.json
index 92d2365d..8c074833 100644
--- a/packages/i18n/src/locales/bg/rules.json
+++ b/packages/i18n/src/locales/bg/rules.json
@@ -146,7 +146,18 @@
     "include": "Включи (бял списък)",
     "exclude": "Изключи (черен списък)",
     "clearAll": "Изчисти всички условия",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "Премахване на {{label}}",
+    "collapse": "Свиване на условията",
+    "userIdInvalid": "Въведете валиден Discord потребителски идентификатор (17–20 цифри)",
+    "addUserId": "Добавяне на потребителски идентификатор",
+    "includeChannels": "Само в тези канали",
+    "includeRoles": "Само членове с тези роли",
+    "includeUsers": "Само тези членове",
+    "excludeChannels": "Никога в тези канали",
+    "excludeRoles": "Никога членове с тези роли",
+    "excludeUsers": "Никога тези членове",
+    "unsupportedWarning": "Този тригер не може да оцени тези филтри ({{filters}}), затова правилото никога няма да се задейства, докато са зададени.",
+    "removeUnsupported": "Премахване на филтрите, които не могат да се приложат"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "Отхвърляне на незапазените промени?",
+    "discardChangesDescription": "Това правило има незапазени промени. Затварянето на редактора ще ги загуби.",
+    "discardChanges": "Отхвърляне на промените",
+    "draftRestored": "Черновата е възстановена от предишна сесия",
+    "discardDraftAction": "Отхвърляне на черновата",
+    "discardTitle": "Отхвърляне на промените?",
+    "discardDescription": "Имате незапазени промени. Черновата се запазва локално, но ще напуснете редактора.",
+    "discardConfirm": "Отхвърляне и затваряне"
   },
   "panel": {
     "trigger": "Trigger Settings",
@@ -322,5 +341,83 @@
     "stepUnreachable": "Step \"{{id}}\" is not reachable from the trigger",
     "noActionType": "{{label}}: no action type selected",
     "fieldRequired": "{{label}}: {{field}} is required"
+  },
+  "eventTypes": {
+    "memberJoin": {
+      "label": "Присъединяване на член",
+      "description": "Когато нов член се присъедини към сървъра"
+    },
+    "memberLeave": {
+      "label": "Напускане на член",
+      "description": "Когато член напусне сървъра"
+    },
+    "memberBanned": {
+      "label": "Блокиран член",
+      "description": "Когато член бъде блокиран"
+    },
+    "memberUnbanned": {
+      "label": "Отблокиран член",
+      "description": "Когато блокирането на член бъде отменено"
+    },
+    "messageDeleted": {
+      "label": "Изтрито съобщение",
+      "description": "Когато съобщение бъде изтрито"
+    },
+    "roleAdded": {
+      "label": "Добавена роля",
+      "description": "Когато на член бъде добавена роля"
+    },
+    "roleRemoved": {
+      "label": "Премахната роля",
+      "description": "Когато от член бъде премахната роля"
+    },
+    "channelCreated": {
+      "label": "Създаден канал",
+      "description": "Когато бъде създаден нов канал"
+    },
+    "channelDeleted": {
+      "label": "Изтрит канал",
+      "description": "Когато канал бъде изтрит"
+    },
+    "voiceJoin": {
+      "label": "Влизане в гласов канал",
+      "description": "Когато член влезе в гласов канал"
+    },
+    "voiceLeave": {
+      "label": "Излизане от гласов канал",
+      "description": "Когато член излезе от гласов канал"
+    },
+    "messageCreated": {
+      "label": "Изпратено съобщение",
+      "description": "Когато в канал бъде изпратено съобщение"
+    },
+    "reactionAdded": {
+      "label": "Добавена реакция",
+      "description": "Когато към съобщение бъде добавена реакция"
+    },
+    "reactionRemoved": {
+      "label": "Премахната реакция",
+      "description": "Когато от съобщение бъде премахната реакция"
+    },
+    "nicknameChanged": {
+      "label": "Променен псевдоним",
+      "description": "Когато псевдонимът на член бъде променен"
+    },
+    "memberTimeout": {
+      "label": "Заглушен член",
+      "description": "Когато член бъде заглушен"
+    },
+    "threadCreated": {
+      "label": "Създадена тема",
+      "description": "Когато бъде създадена нова тема"
+    },
+    "boostStart": {
+      "label": "Начало на буст",
+      "description": "Когато член започне да бустиба сървъра"
+    },
+    "boostEnd": {
+      "label": "Край на буст",
+      "description": "Когато член спре да бустиба сървъра"
+    }
   }
 }
diff --git a/packages/i18n/src/locales/bn/common.json b/packages/i18n/src/locales/bn/common.json
index b261d2d5..0e22cddd 100644
--- a/packages/i18n/src/locales/bn/common.json
+++ b/packages/i18n/src/locales/bn/common.json
@@ -90,7 +90,9 @@
     "saving": "সংরক্ষণ হচ্ছে...",
     "saveSettings": "সেটিংস সংরক্ষণ করুন",
     "previous": "পূর্ববর্তী",
-    "next": "পরবর্তী"
+    "next": "পরবর্তী",
+    "invalidJson": "বৈধ JSON নয় — টেক্সট মানের একটি অবজেক্ট প্রত্যাশিত",
+    "fieldRequired": "{{field}} আবশ্যক"
   },
   "pagination": {
     "previous": "পূর্ববর্তী",
diff --git a/packages/i18n/src/locales/bn/rules.json b/packages/i18n/src/locales/bn/rules.json
index a066aef5..cb432f42 100644
--- a/packages/i18n/src/locales/bn/rules.json
+++ b/packages/i18n/src/locales/bn/rules.json
@@ -146,7 +146,18 @@
     "include": "অন্তর্ভুক্ত (হোয়াইটলিস্ট)",
     "exclude": "বর্জন (ব্ল্যাকলিস্ট)",
     "clearAll": "সমস্ত শর্ত সাফ করুন",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "{{label}} সরান",
+    "collapse": "শর্তগুলি সংকুচিত করুন",
+    "userIdInvalid": "একটি বৈধ Discord ব্যবহারকারী আইডি লিখুন (১৭–২০ সংখ্যা)",
+    "addUserId": "ব্যবহারকারী আইডি যোগ করুন",
+    "includeChannels": "শুধু এই চ্যানেলগুলিতে",
+    "includeRoles": "শুধু এই ভূমিকাগুলির সদস্যরা",
+    "includeUsers": "শুধু এই সদস্যরা",
+    "excludeChannels": "কখনও এই চ্যানেলগুলিতে নয়",
+    "excludeRoles": "কখনও এই ভূমিকাগুলির সদস্যরা নয়",
+    "excludeUsers": "কখনও এই সদস্যরা নয়",
+    "unsupportedWarning": "এই ট্রিগারটি এই ফিল্টারগুলি ({{filters}}) মূল্যায়ন করতে পারে না, তাই সেগুলি সেট থাকা অবস্থায় নিয়মটি কখনও চলবে না।",
+    "removeUnsupported": "যে ফিল্টারগুলি প্রযোজ্য নয় সেগুলি সরান"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "অসংরক্ষিত পরিবর্তন বাতিল করবেন?",
+    "discardChangesDescription": "এই নিয়মে এমন পরিবর্তন আছে যা সংরক্ষণ করা হয়নি। সম্পাদক বন্ধ করলে সেগুলি হারিয়ে যাবে।",
+    "discardChanges": "পরিবর্তন বাতিল করুন",
+    "draftRestored": "আগের সেশন থেকে খসড়া পুনরুদ্ধার করা হয়েছে",
+    "discardDraftAction": "খসড়া বাতিল করুন",
+    "discardTitle": "পরিবর্তন বাতিল করবেন?",
+    "discardDescription": "আপনার অসংরক্ষিত পরিবর্তন আছে। খসড়া স্থানীয়ভাবে সংরক্ষিত থাকবে, তবে আপনি সম্পাদক ছেড়ে যাবেন।",
+    "discardConfirm": "বাতিল করে বন্ধ করুন"
   },
   "panel": {
     "trigger": "Trigger Settings",
@@ -322,5 +341,83 @@
     "stepUnreachable": "Step \"{{id}}\" is not reachable from the trigger",
     "noActionType": "{{label}}: no action type selected",
     "fieldRequired": "{{label}}: {{field}} is required"
+  },
+  "eventTypes": {
+    "memberJoin": {
+      "label": "সদস্য যোগদান",
+      "description": "যখন একজন নতুন সদস্য সার্ভারে যোগ দেয়"
+    },
+    "memberLeave": {
+      "label": "সদস্য প্রস্থান",
+      "description": "যখন একজন সদস্য সার্ভার ছেড়ে যায়"
+    },
+    "memberBanned": {
+      "label": "সদস্য নিষিদ্ধ",
+      "description": "যখন একজন সদস্যকে নিষিদ্ধ করা হয়"
+    },
+    "memberUnbanned": {
+      "label": "সদস্যের নিষেধাজ্ঞা প্রত্যাহার",
+      "description": "যখন একজন সদস্যের নিষেধাজ্ঞা তুলে নেওয়া হয়"
+    },
+    "messageDeleted": {
+      "label": "বার্তা মুছে ফেলা",
+      "description": "যখন একটি বার্তা মুছে ফেলা হয়"
+    },
+    "roleAdded": {
+      "label": "ভূমিকা যোগ",
+      "description": "যখন একজন সদস্যের ভূমিকা যোগ করা হয়"
+    },
+    "roleRemoved": {
+      "label": "ভূমিকা অপসারণ",
+      "description": "যখন একজন সদস্যের ভূমিকা সরানো হয়"
+    },
+    "channelCreated": {
+      "label": "চ্যানেল তৈরি",
+      "description": "যখন একটি নতুন চ্যানেল তৈরি হয়"
+    },
+    "channelDeleted": {
+      "label": "চ্যানেল মুছে ফেলা",
+      "description": "যখন একটি চ্যানেল মুছে ফেলা হয়"
+    },
+    "voiceJoin": {
+      "label": "ভয়েসে যোগদান",
+      "description": "যখন একজন সদস্য ভয়েস চ্যানেলে যোগ দেয়"
+    },
+    "voiceLeave": {
+      "label": "ভয়েস ত্যাগ",
+      "description": "যখন একজন সদস্য ভয়েস চ্যানেল ছাড়ে"
+    },
+    "messageCreated": {
+      "label": "বার্তা পাঠানো",
+      "description": "যখন একটি চ্যানেলে বার্তা পাঠানো হয়"
+    },
+    "reactionAdded": {
+      "label": "প্রতিক্রিয়া যোগ",
+      "description": "যখন একটি বার্তায় প্রতিক্রিয়া যোগ করা হয়"
+    },
+    "reactionRemoved": {
+      "label": "প্রতিক্রিয়া অপসারণ",
+      "description": "যখন একটি বার্তা থেকে প্রতিক্রিয়া সরানো হয়"
+    },
+    "nicknameChanged": {
+      "label": "ডাকনাম পরিবর্তন",
+      "description": "যখন একজন সদস্যের ডাকনাম পরিবর্তন হয়"
+    },
+    "memberTimeout": {
+      "label": "সদস্য টাইমআউট",
+      "description": "যখন একজন সদস্যকে টাইমআউট করা হয়"
+    },
+    "threadCreated": {
+      "label": "থ্রেড তৈরি",
+      "description": "যখন একটি নতুন থ্রেড তৈরি হয়"
+    },
+    "boostStart": {
+      "label": "বুস্ট শুরু",
+      "description": "যখন একজন সদস্য সার্ভার বুস্ট করা শুরু করে"
+    },
+    "boostEnd": {
+      "label": "বুস্ট শেষ",
+      "description": "যখন একজন সদস্য সার্ভার বুস্ট করা বন্ধ করে"
+    }
   }
 }
diff --git a/packages/i18n/src/locales/ca/common.json b/packages/i18n/src/locales/ca/common.json
index eadb5e8c..d3adbd6e 100644
--- a/packages/i18n/src/locales/ca/common.json
+++ b/packages/i18n/src/locales/ca/common.json
@@ -90,7 +90,9 @@
     "saving": "Desant...",
     "saveSettings": "Desar configuració",
     "previous": "Anterior",
-    "next": "Següent"
+    "next": "Següent",
+    "invalidJson": "JSON no vàlid: s'espera un objecte de valors de text",
+    "fieldRequired": "{{field}} és obligatori"
   },
   "pagination": {
     "previous": "Anterior",
diff --git a/packages/i18n/src/locales/ca/rules.json b/packages/i18n/src/locales/ca/rules.json
index 9cebc1c8..2fd9e470 100644
--- a/packages/i18n/src/locales/ca/rules.json
+++ b/packages/i18n/src/locales/ca/rules.json
@@ -146,7 +146,18 @@
     "include": "Incloure (llista blanca)",
     "exclude": "Excloure (llista negra)",
     "clearAll": "Netejar totes les condicions",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "Elimina {{label}}",
+    "collapse": "Replega les condicions",
+    "userIdInvalid": "Introdueix un ID d'usuari de Discord vàlid (17–20 dígits)",
+    "addUserId": "Afegeix un ID d'usuari",
+    "includeChannels": "Només en aquests canals",
+    "includeRoles": "Només membres amb aquests rols",
+    "includeUsers": "Només aquests membres",
+    "excludeChannels": "Mai en aquests canals",
+    "excludeRoles": "Mai membres amb aquests rols",
+    "excludeUsers": "Mai aquests membres",
+    "unsupportedWarning": "Aquest activador no pot avaluar aquests filtres ({{filters}}), de manera que la regla no s'executarà mai mentre estiguin definits.",
+    "removeUnsupported": "Elimina els filtres que no es poden aplicar"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "Voleu descartar els canvis no desats?",
+    "discardChangesDescription": "Aquesta regla té canvis que no s'han desat. Si tanqueu l'editor, es perdran.",
+    "discardChanges": "Descarta els canvis",
+    "draftRestored": "Esborrany restaurat d'una sessió anterior",
+    "discardDraftAction": "Descarta l'esborrany",
+    "discardTitle": "Voleu descartar els canvis?",
+    "discardDescription": "Teniu canvis sense desar. L'esborrany es desa localment, però sortireu de l'editor.",
+    "discardConfirm": "Descarta i tanca"
   },
   "panel": {
     "trigger": "Trigger Settings",
@@ -322,5 +341,83 @@
     "stepUnreachable": "Step \"{{id}}\" is not reachable from the trigger",
     "noActionType": "{{label}}: no action type selected",
     "fieldRequired": "{{label}}: {{field}} is required"
+  },
+  "eventTypes": {
+    "memberJoin": {
+      "label": "Entrada de membre",
+      "description": "Quan un membre nou entra al servidor"
+    },
+    "memberLeave": {
+      "label": "Sortida de membre",
+      "description": "Quan un membre surt del servidor"
+    },
+    "memberBanned": {
+      "label": "Membre expulsat",
+      "description": "Quan s'expulsa un membre"
+    },
+    "memberUnbanned": {
+      "label": "Membre readmès",
+      "description": "Quan es readmet un membre"
+    },
+    "messageDeleted": {
+      "label": "Missatge suprimit",
+      "description": "Quan se suprimeix un missatge"
+    },
+    "roleAdded": {
+      "label": "Rol afegit",
+      "description": "Quan s'afegeix un rol a un membre"
+    },
+    "roleRemoved": {
+      "label": "Rol suprimit",
+      "description": "Quan es lleva un rol a un membre"
+    },
+    "channelCreated": {
+      "label": "Canal creat",
+      "description": "Quan es crea un canal nou"
+    },
+    "channelDeleted": {
+      "label": "Canal suprimit",
+      "description": "Quan se suprimeix un canal"
+    },
+    "voiceJoin": {
+      "label": "Entrada a veu",
+      "description": "Quan un membre entra a un canal de veu"
+    },
+    "voiceLeave": {
+      "label": "Sortida de veu",
+      "description": "Quan un membre surt d'un canal de veu"
+    },
+    "messageCreated": {
+      "label": "Missatge enviat",
+      "description": "Quan s'envia un missatge a un canal"
+    },
+    "reactionAdded": {
+      "label": "Reacció afegida",
+      "description": "Quan s'afegeix una reacció a un missatge"
+    },
+    "reactionRemoved": {
+      "label": "Reacció suprimida",
+      "description": "Quan es lleva una reacció d'un missatge"
+    },
+    "nicknameChanged": {
+      "label": "Sobrenom canviat",
+      "description": "Quan es canvia el sobrenom d'un membre"
+    },
+    "memberTimeout": {
+      "label": "Membre silenciat",
+      "description": "Quan es silencia un membre"
+    },
+    "threadCreated": {
+      "label": "Fil creat",
+      "description": "Quan es crea un fil nou"
+    },
+    "boostStart": {
+      "label": "Inici de millora",
+      "description": "Quan un membre comença a millorar el servidor"
+    },
+    "boostEnd": {
+      "label": "Fi de millora",
+      "description": "Quan un membre deixa de millorar el servidor"
+    }
   }
 }
diff --git a/packages/i18n/src/locales/cs/common.json b/packages/i18n/src/locales/cs/common.json
index cdb3fa47..1ef29d6e 100644
--- a/packages/i18n/src/locales/cs/common.json
+++ b/packages/i18n/src/locales/cs/common.json
@@ -90,7 +90,9 @@
     "saving": "Ukládání...",
     "saveSettings": "Uložit nastavení",
     "previous": "Předchozí",
-    "next": "Další"
+    "next": "Další",
+    "invalidJson": "Neplatný JSON — očekáván objekt textových hodnot",
+    "fieldRequired": "{{field}} je povinné"
   },
   "pagination": {
     "previous": "Předchozí",
diff --git a/packages/i18n/src/locales/cs/rules.json b/packages/i18n/src/locales/cs/rules.json
index 18f5bf4e..3056b5ac 100644
--- a/packages/i18n/src/locales/cs/rules.json
+++ b/packages/i18n/src/locales/cs/rules.json
@@ -146,7 +146,18 @@
     "include": "Zahrnout (bílá listina)",
     "exclude": "Vyloučit (černá listina)",
     "clearAll": "Vymazat všechny podmínky",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "Odebrat {{label}}",
+    "collapse": "Sbalit podmínky",
+    "userIdInvalid": "Zadejte platné Discord ID uživatele (17–20 číslic)",
+    "addUserId": "Přidat ID uživatele",
+    "includeChannels": "Pouze v těchto kanálech",
+    "includeRoles": "Pouze členové s těmito rolemi",
+    "includeUsers": "Pouze tito členové",
+    "excludeChannels": "Nikdy v těchto kanálech",
+    "excludeRoles": "Nikdy členové s těmito rolemi",
+    "excludeUsers": "Nikdy tito členové",
+    "unsupportedWarning": "Tato spouštěč nedokáže vyhodnotit tyto filtry ({{filters}}), takže se pravidlo nikdy nespustí, dokud jsou nastavené.",
+    "removeUnsupported": "Odebrat filtry, které nelze použít"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "Zahodit neuložené změny?",
+    "discardChangesDescription": "Toto pravidlo obsahuje neuložené úpravy. Zavřením editoru o ně přijdete.",
+    "discardChanges": "Zahodit změny",
+    "draftRestored": "Koncept obnoven z předchozí relace",
+    "discardDraftAction": "Zahodit koncept",
+    "discardTitle": "Zahodit změny?",
+    "discardDescription": "Máte neuložené změny. Koncept se ukládá lokálně, ale opustíte editor.",
+    "discardConfirm": "Zahodit a zavřít"
   },
   "panel": {
     "trigger": "Trigger Settings",
@@ -322,5 +341,83 @@
     "stepUnreachable": "Step \"{{id}}\" is not reachable from the trigger",
     "noActionType": "{{label}}: no action type selected",
     "fieldRequired": "{{label}}: {{field}} is required"
+  },
+  "eventTypes": {
+    "memberJoin": {
+      "label": "Připojení člena",
+      "description": "Když se k serveru připojí nový člen"
+    },
+    "memberLeave": {
+      "label": "Odchod člena",
+      "description": "Když člen opustí server"
+    },
+    "memberBanned": {
+      "label": "Zabanování člena",
+      "description": "Když je člen zabanován"
+    },
+    "memberUnbanned": {
+      "label": "Odbanování člena",
+      "description": "Když je členovi zrušen ban"
+    },
+    "messageDeleted": {
+      "label": "Smazaná zpráva",
+      "description": "Když je smazána zpráva"
+    },
+    "roleAdded": {
+      "label": "Přidaná role",
+      "description": "Když je členovi přidána role"
+    },
+    "roleRemoved": {
+      "label": "Odebraná role",
+      "description": "Když je členovi odebrána role"
+    },
+    "channelCreated": {
+      "label": "Vytvořený kanál",
+      "description": "Když je vytvořen nový kanál"
+    },
+    "channelDeleted": {
+      "label": "Smazaný kanál",
+      "description": "Když je smazán kanál"
+    },
+    "voiceJoin": {
+      "label": "Připojení k hlasu",
+      "description": "Když se člen připojí k hlasovému kanálu"
+    },
+    "voiceLeave": {
+      "label": "Opuštění hlasu",
+      "description": "Když člen opustí hlasový kanál"
+    },
+    "messageCreated": {
+      "label": "Odeslaná zpráva",
+      "description": "Když je v kanálu odeslána zpráva"
+    },
+    "reactionAdded": {
+      "label": "Přidaná reakce",
+      "description": "Když je ke zprávě přidána reakce"
+    },
+    "reactionRemoved": {
+      "label": "Odebraná reakce",
+      "description": "Když je ze zprávy odebrána reakce"
+    },
+    "nicknameChanged": {
+      "label": "Změna přezdívky",
+      "description": "Když je změněna přezdívka člena"
+    },
+    "memberTimeout": {
+      "label": "Umlčení člena",
+      "description": "Když je člen umlčen"
+    },
+    "threadCreated": {
+      "label": "Vytvořené vlákno",
+      "description": "Když je vytvořeno nové vlákno"
+    },
+    "boostStart": {
+      "label": "Začátek boostu",
+      "description": "Když člen začne boostovat server"
+    },
+    "boostEnd": {
+      "label": "Konec boostu",
+      "description": "Když člen přestane boostovat server"
+    }
   }
 }
diff --git a/packages/i18n/src/locales/da/common.json b/packages/i18n/src/locales/da/common.json
index c751d9f1..4255fcd9 100644
--- a/packages/i18n/src/locales/da/common.json
+++ b/packages/i18n/src/locales/da/common.json
@@ -90,7 +90,9 @@
     "saving": "Gemmer...",
     "saveSettings": "Gem indstillinger",
     "previous": "Forrige",
-    "next": "Næste"
+    "next": "Næste",
+    "invalidJson": "Ikke gyldig JSON — der forventes et objekt med tekstværdier",
+    "fieldRequired": "{{field}} er påkrævet"
   },
   "pagination": {
     "previous": "Forrige",
diff --git a/packages/i18n/src/locales/da/rules.json b/packages/i18n/src/locales/da/rules.json
index 0a2b08aa..3aebeef9 100644
--- a/packages/i18n/src/locales/da/rules.json
+++ b/packages/i18n/src/locales/da/rules.json
@@ -146,7 +146,18 @@
     "include": "Inkluder (hvidliste)",
     "exclude": "Ekskluder (sortliste)",
     "clearAll": "Ryd alle betingelser",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "Fjern {{label}}",
+    "collapse": "Skjul betingelser",
+    "userIdInvalid": "Indtast et gyldigt Discord-bruger-id (17–20 cifre)",
+    "addUserId": "Tilføj bruger-id",
+    "includeChannels": "Kun i disse kanaler",
+    "includeRoles": "Kun medlemmer med disse roller",
+    "includeUsers": "Kun disse medlemmer",
+    "excludeChannels": "Aldrig i disse kanaler",
+    "excludeRoles": "Aldrig medlemmer med disse roller",
+    "excludeUsers": "Aldrig disse medlemmer",
+    "unsupportedWarning": "Denne udløser kan ikke evaluere disse filtre ({{filters}}), så reglen udløses aldrig, så længe de er angivet.",
+    "removeUnsupported": "Fjern filtre, der ikke kan anvendes"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "Kassér ikke-gemte ændringer?",
+    "discardChangesDescription": "Denne regel har ændringer, der ikke er gemt. Hvis du lukker editoren, går de tabt.",
+    "discardChanges": "Kassér ændringer",
+    "draftRestored": "Kladde gendannet fra en tidligere session",
+    "discardDraftAction": "Kassér kladde",
+    "discardTitle": "Kassér ændringer?",
+    "discardDescription": "Du har ikke-gemte ændringer. Din kladde gemmes lokalt, men du forlader editoren.",
+    "discardConfirm": "Kassér og luk"
   },
   "panel": {
     "trigger": "Trigger Settings",
@@ -322,5 +341,83 @@
     "stepUnreachable": "Step \"{{id}}\" is not reachable from the trigger",
     "noActionType": "{{label}}: no action type selected",
     "fieldRequired": "{{label}}: {{field}} is required"
+  },
+  "eventTypes": {
+    "memberJoin": {
+      "label": "Medlem tilsluttet",
+      "description": "Når et nyt medlem tilslutter sig serveren"
+    },
+    "memberLeave": {
+      "label": "Medlem forladt",
+      "description": "Når et medlem forlader serveren"
+    },
+    "memberBanned": {
+      "label": "Medlem bortvist",
+      "description": "Når et medlem bortvises"
+    },
+    "memberUnbanned": {
+      "label": "Medlem genindsat",
+      "description": "Når et medlems bortvisning ophæves"
+    },
+    "messageDeleted": {
+      "label": "Besked slettet",
+      "description": "Når en besked slettes"
+    },
+    "roleAdded": {
+      "label": "Rolle tilføjet",
+      "description": "Når et medlem får tildelt en rolle"
+    },
+    "roleRemoved": {
+      "label": "Rolle fjernet",
+      "description": "Når en rolle fjernes fra et medlem"
+    },
+    "channelCreated": {
+      "label": "Kanal oprettet",
+      "description": "Når en ny kanal oprettes"
+    },
+    "channelDeleted": {
+      "label": "Kanal slettet",
+      "description": "Når en kanal slettes"
+    },
+    "voiceJoin": {
+      "label": "Tilslutter tale",
+      "description": "Når et medlem tilslutter sig en talekanal"
+    },
+    "voiceLeave": {
+      "label": "Forlader tale",
+      "description": "Når et medlem forlader en talekanal"
+    },
+    "messageCreated": {
+      "label": "Besked sendt",
+      "description": "Når der sendes en besked i en kanal"
+    },
+    "reactionAdded": {
+      "label": "Reaktion tilføjet",
+      "description": "Når der tilføjes en reaktion til en besked"
+    },
+    "reactionRemoved": {
+      "label": "Reaktion fjernet",
+      "description": "Når en reaktion fjernes fra en besked"
+    },
+    "nicknameChanged": {
+      "label": "Kaldenavn ændret",
+      "description": "Når et medlems kaldenavn ændres"
+    },
+    "memberTimeout": {
+      "label": "Medlem tavsgjort",
+      "description": "Når et medlem gøres tavs"
+    },
+    "threadCreated": {
+      "label": "Tråd oprettet",
+      "description": "Når en ny tråd oprettes"
+    },
+    "boostStart": {
+      "label": "Boost startet",
+      "description": "Når et medlem begynder at booste serveren"
+    },
+    "boostEnd": {
+      "label": "Boost afsluttet",
+      "description": "Når et medlem holder op med at booste serveren"
+    }
   }
 }
diff --git a/packages/i18n/src/locales/de/common.json b/packages/i18n/src/locales/de/common.json
index 6f21036f..a70f3290 100644
--- a/packages/i18n/src/locales/de/common.json
+++ b/packages/i18n/src/locales/de/common.json
@@ -90,7 +90,9 @@
     "saving": "Speichern...",
     "saveSettings": "Einstellungen speichern",
     "previous": "Zurück",
-    "next": "Weiter"
+    "next": "Weiter",
+    "invalidJson": "Kein gültiges JSON — erwartet wird ein Objekt aus Textwerten",
+    "fieldRequired": "{{field}} ist erforderlich"
   },
   "pagination": {
     "previous": "Zurück",
diff --git a/packages/i18n/src/locales/de/rules.json b/packages/i18n/src/locales/de/rules.json
index 0b8226f7..04c94b3b 100644
--- a/packages/i18n/src/locales/de/rules.json
+++ b/packages/i18n/src/locales/de/rules.json
@@ -146,7 +146,18 @@
     "include": "Einschließen (Whitelist)",
     "exclude": "Ausschließen (Blacklist)",
     "clearAll": "Alle Bedingungen löschen",
-    "removeItem": "{{label}} entfernen"
+    "removeItem": "{{label}} entfernen",
+    "collapse": "Bedingungen einklappen",
+    "userIdInvalid": "Gib eine gültige Discord-Benutzer-ID ein (17–20 Ziffern)",
+    "addUserId": "Benutzer-ID hinzufügen",
+    "includeChannels": "Nur in diesen Kanälen",
+    "includeRoles": "Nur Mitglieder mit diesen Rollen",
+    "includeUsers": "Nur diese Mitglieder",
+    "excludeChannels": "Nie in diesen Kanälen",
+    "excludeRoles": "Nie Mitglieder mit diesen Rollen",
+    "excludeUsers": "Nie diese Mitglieder",
+    "unsupportedWarning": "Dieser Auslöser kann diese Filter ({{filters}}) nicht auswerten, daher wird die Regel nie ausgelöst, solange sie gesetzt sind.",
+    "removeUnsupported": "Filter entfernen, die nicht greifen können"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Ansicht anpassen"
     },
     "issues_one": "{{count}} Problem",
-    "issues_other": "{{count}} Probleme"
+    "issues_other": "{{count}} Probleme",
+    "discardChangesTitle": "Nicht gespeicherte Änderungen verwerfen?",
+    "discardChangesDescription": "Diese Regel enthält nicht gespeicherte Änderungen. Beim Schließen des Editors gehen sie verloren.",
+    "discardChanges": "Änderungen verwerfen",
+    "draftRestored": "Entwurf aus einer früheren Sitzung wiederhergestellt",
+    "discardDraftAction": "Entwurf verwerfen",
+    "discardTitle": "Änderungen verwerfen?",
+    "discardDescription": "Du hast nicht gespeicherte Änderungen. Dein Entwurf wird lokal gespeichert, aber du verlässt den Editor.",
+    "discardConfirm": "Verwerfen & schließen"
   },
   "panel": {
     "trigger": "Auslöser-Einstellungen",
@@ -322,5 +341,83 @@
     "stepUnreachable": "Schritt \"{{id}}\" ist vom Auslöser aus nicht erreichbar",
     "noActionType": "{{label}}: kein Aktionstyp ausgewählt",
     "fieldRequired": "{{label}}: {{field}} ist erforderlich"
+  },
+  "eventTypes": {
+    "memberJoin": {
+      "label": "Mitglied beigetreten",
+      "description": "Wenn ein neues Mitglied dem Server beitritt"
+    },
+    "memberLeave": {
+      "label": "Mitglied verlassen",
+      "description": "Wenn ein Mitglied den Server verlässt"
+    },
+    "memberBanned": {
+      "label": "Mitglied gebannt",
+      "description": "Wenn ein Mitglied gebannt wird"
+    },
+    "memberUnbanned": {
+      "label": "Bann aufgehoben",
+      "description": "Wenn der Bann eines Mitglieds aufgehoben wird"
+    },
+    "messageDeleted": {
+      "label": "Nachricht gelöscht",
+      "description": "Wenn eine Nachricht gelöscht wird"
+    },
+    "roleAdded": {
+      "label": "Rolle hinzugefügt",
+      "description": "Wenn einem Mitglied eine Rolle hinzugefügt wird"
+    },
+    "roleRemoved": {
+      "label": "Rolle entfernt",
+      "description": "Wenn einem Mitglied eine Rolle entzogen wird"
+    },
+    "channelCreated": {
+      "label": "Kanal erstellt",
+      "description": "Wenn ein neuer Kanal erstellt wird"
+    },
+    "channelDeleted": {
+      "label": "Kanal gelöscht",
+      "description": "Wenn ein Kanal gelöscht wird"
+    },
+    "voiceJoin": {
+      "label": "Sprachkanal betreten",
+      "description": "Wenn ein Mitglied einen Sprachkanal betritt"
+    },
+    "voiceLeave": {
+      "label": "Sprachkanal verlassen",
+      "description": "Wenn ein Mitglied einen Sprachkanal verlässt"
+    },
+    "messageCreated": {
+      "label": "Nachricht gesendet",
+      "description": "Wenn in einem Kanal eine Nachricht gesendet wird"
+    },
+    "reactionAdded": {
+      "label": "Reaktion hinzugefügt",
+      "description": "Wenn einer Nachricht eine Reaktion hinzugefügt wird"
+    },
+    "reactionRemoved": {
+      "label": "Reaktion entfernt",
+      "description": "Wenn eine Reaktion von einer Nachricht entfernt wird"
+    },
+    "nicknameChanged": {
+      "label": "Spitzname geändert",
+      "description": "Wenn der Spitzname eines Mitglieds geändert wird"
+    },
+    "memberTimeout": {
+      "label": "Mitglied stummgeschaltet",
+      "description": "Wenn ein Mitglied stummgeschaltet wird"
+    },
+    "threadCreated": {
+      "label": "Thread erstellt",
+      "description": "Wenn ein neuer Thread erstellt wird"
+    },
+    "boostStart": {
+      "label": "Boost gestartet",
+      "description": "Wenn ein Mitglied beginnt, den Server zu boosten"
+    },
+    "boostEnd": {
+      "label": "Boost beendet",
+      "description": "Wenn ein Mitglied aufhört, den Server zu boosten"
+    }
   }
 }
diff --git a/packages/i18n/src/locales/el/common.json b/packages/i18n/src/locales/el/common.json
index de476fe0..a7046949 100644
--- a/packages/i18n/src/locales/el/common.json
+++ b/packages/i18n/src/locales/el/common.json
@@ -90,7 +90,9 @@
     "saving": "Αποθήκευση...",
     "saveSettings": "Αποθήκευση ρυθμίσεων",
     "previous": "Προηγούμενο",
-    "next": "Επόμενο"
+    "next": "Επόμενο",
+    "invalidJson": "Μη έγκυρο JSON — αναμένεται αντικείμενο με τιμές κειμένου",
+    "fieldRequired": "Το πεδίο {{field}} είναι υποχρεωτικό"
   },
   "pagination": {
     "previous": "Προηγούμενο",
diff --git a/packages/i18n/src/locales/el/rules.json b/packages/i18n/src/locales/el/rules.json
index 263e9584..b1a4d563 100644
--- a/packages/i18n/src/locales/el/rules.json
+++ b/packages/i18n/src/locales/el/rules.json
@@ -146,7 +146,18 @@
     "include": "Συμπερίληψη (λευκή λίστα)",
     "exclude": "Εξαίρεση (μαύρη λίστα)",
     "clearAll": "Εκκαθάριση όλων των συνθηκών",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "Κατάργηση {{label}}",
+    "collapse": "Σύμπτυξη συνθηκών",
+    "userIdInvalid": "Εισαγάγετε έγκυρο αναγνωριστικό χρήστη Discord (17–20 ψηφία)",
+    "addUserId": "Προσθήκη αναγνωριστικού χρήστη",
+    "includeChannels": "Μόνο σε αυτά τα κανάλια",
+    "includeRoles": "Μόνο μέλη με αυτούς τους ρόλους",
+    "includeUsers": "Μόνο αυτά τα μέλη",
+    "excludeChannels": "Ποτέ σε αυτά τα κανάλια",
+    "excludeRoles": "Ποτέ μέλη με αυτούς τους ρόλους",
+    "excludeUsers": "Ποτέ αυτά τα μέλη",
+    "unsupportedWarning": "Αυτή η ενεργοποίηση δεν μπορεί να αξιολογήσει αυτά τα φίλτρα ({{filters}}), οπότε ο κανόνας δεν θα εκτελεστεί ποτέ όσο είναι ορισμένα.",
+    "removeUnsupported": "Κατάργηση φίλτρων που δεν μπορούν να εφαρμοστούν"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "Απόρριψη μη αποθηκευμένων αλλαγών;",
+    "discardChangesDescription": "Αυτός ο κανόνας έχει αλλαγές που δεν έχουν αποθηκευτεί. Αν κλείσετε το πρόγραμμα επεξεργασίας, θα χαθούν.",
+    "discardChanges": "Απόρριψη αλλαγών",
+    "draftRestored": "Το πρόχειρο αποκαταστάθηκε από προηγούμενη συνεδρία",
+    "discardDraftAction": "Απόρριψη προχείρου",
+    "discardTitle": "Απόρριψη αλλαγών;",
+    "discardDescription": "Έχετε μη αποθηκευμένες αλλαγές. Το πρόχειρο αποθηκεύεται τοπικά, αλλά θα φύγετε από το πρόγραμμα επεξεργασίας.",
+    "discardConfirm": "Απόρριψη και κλείσιμο"
   },
   "panel": {
     "trigger": "Trigger Settings",
@@ -322,5 +341,83 @@
     "stepUnreachable": "Step \"{{id}}\" is not reachable from the trigger",
     "noActionType": "{{label}}: no action type selected",
     "fieldRequired": "{{label}}: {{field}} is required"
+  },
+  "eventTypes": {
+    "memberJoin": {
+      "label": "Είσοδος μέλους",
+      "description": "Όταν ένα νέο μέλος μπαίνει στον διακομιστή"
+    },
+    "memberLeave": {
+      "label": "Αποχώρηση μέλους",
+      "description": "Όταν ένα μέλος φεύγει από τον διακομιστή"
+    },
+    "memberBanned": {
+      "label": "Αποκλεισμός μέλους",
+      "description": "Όταν ένα μέλος αποκλείεται"
+    },
+    "memberUnbanned": {
+      "label": "Άρση αποκλεισμού",
+      "description": "Όταν αίρεται ο αποκλεισμός ενός μέλους"
+    },
+    "messageDeleted": {
+      "label": "Διαγραφή μηνύματος",
+      "description": "Όταν διαγράφεται ένα μήνυμα"
+    },
+    "roleAdded": {
+      "label": "Προσθήκη ρόλου",
+      "description": "Όταν προστίθεται ρόλος σε ένα μέλος"
+    },
+    "roleRemoved": {
+      "label": "Αφαίρεση ρόλου",
+      "description": "Όταν αφαιρείται ρόλος από ένα μέλος"
+    },
+    "channelCreated": {
+      "label": "Δημιουργία καναλιού",
+      "description": "Όταν δημιουργείται νέο κανάλι"
+    },
+    "channelDeleted": {
+      "label": "Διαγραφή καναλιού",
+      "description": "Όταν διαγράφεται ένα κανάλι"
+    },
+    "voiceJoin": {
+      "label": "Είσοδος σε φωνή",
+      "description": "Όταν ένα μέλος μπαίνει σε φωνητικό κανάλι"
+    },
+    "voiceLeave": {
+      "label": "Αποχώρηση από φωνή",
+      "description": "Όταν ένα μέλος φεύγει από φωνητικό κανάλι"
+    },
+    "messageCreated": {
+      "label": "Αποστολή μηνύματος",
+      "description": "Όταν στέλνεται μήνυμα σε ένα κανάλι"
+    },
+    "reactionAdded": {
+      "label": "Προσθήκη αντίδρασης",
+      "description": "Όταν προστίθεται αντίδραση σε ένα μήνυμα"
+    },
+    "reactionRemoved": {
+      "label": "Αφαίρεση αντίδρασης",
+      "description": "Όταν αφαιρείται αντίδραση από ένα μήνυμα"
+    },
+    "nicknameChanged": {
+      "label": "Αλλαγή ψευδωνύμου",
+      "description": "Όταν αλλάζει το ψευδώνυμο ενός μέλους"
+    },
+    "memberTimeout": {
+      "label": "Σίγαση μέλους",
+      "description": "Όταν ένα μέλος τίθεται σε σίγαση"
+    },
+    "threadCreated": {
+      "label": "Δημιουργία νήματος",
+      "description": "Όταν δημιουργείται νέο νήμα"
+    },
+    "boostStart": {
+      "label": "Έναρξη ενίσχυσης",
+      "description": "Όταν ένα μέλος αρχίζει να ενισχύει τον διακομιστή"
+    },
+    "boostEnd": {
+      "label": "Λήξη ενίσχυσης",
+      "description": "Όταν ένα μέλος σταματά να ενισχύει τον διακομιστή"
+    }
   }
 }
diff --git a/packages/i18n/src/locales/en/common.json b/packages/i18n/src/locales/en/common.json
index 6cb89a41..c85f5485 100644
--- a/packages/i18n/src/locales/en/common.json
+++ b/packages/i18n/src/locales/en/common.json
@@ -92,7 +92,13 @@
     "saving": "Saving...",
     "saveSettings": "Save Settings",
     "previous": "Previous",
-    "next": "Next"
+    "next": "Next",
+    "invalidJson": "Not valid JSON — expected an object of text values",
+    "fieldRequired": "{{field}} is required",
+    "removeItem": "Remove {{label}}",
+    "selectedCount_one": "{{count}} selected",
+    "selectedCount_other": "{{count}} selected",
+    "loading": "Loading..."
   },
   "pagination": {
     "previous": "Previous",
diff --git a/packages/i18n/src/locales/en/rules.json b/packages/i18n/src/locales/en/rules.json
index 52934640..8aabfc5e 100644
--- a/packages/i18n/src/locales/en/rules.json
+++ b/packages/i18n/src/locales/en/rules.json
@@ -80,7 +80,8 @@
     "boostThankYouDefault": "Thank you for boosting {guild}, {user}! You're awesome!",
     "banLoggerName": "Ban Logger",
     "autoThreadName": "Auto Thread",
-    "autoThreadDefault": "Discussion: {user.name}"
+    "autoThreadDefault": "Discussion: {user.name}",
+    "browse": "Browse templates"
   },
   "deleteDialog": {
     "title": "Delete Rule",
@@ -150,7 +151,17 @@
     "removeItem": "Remove {{label}}",
     "collapse": "Collapse conditions",
     "userIdInvalid": "Enter a valid Discord user ID (17–20 digits)",
-    "addUserId": "Add user ID"
+    "addUserId": "Add user ID",
+    "includeChannels": "Only in these channels",
+    "includeRoles": "Only members with these roles",
+    "includeUsers": "Only these members",
+    "excludeChannels": "Never in these channels",
+    "excludeRoles": "Never members with these roles",
+    "excludeUsers": "Never these members",
+    "unsupportedWarning": "This trigger cannot evaluate these filters ({{filters}}), so the rule will never fire while they are set.",
+    "removeUnsupported": "Remove filters that cannot apply",
+    "addMember": "Add member...",
+    "memberSearchHint": "Type a name to search members"
   },
   "editor": {
     "backToRules": "Rules",
@@ -176,7 +187,14 @@
     "discardDescription": "You have unsaved changes. Your draft is saved locally, but you'll leave the editor.",
     "discardConfirm": "Discard & close",
     "draftRestored": "Draft restored from a previous session",
-    "discardDraftAction": "Discard draft"
+    "discardDraftAction": "Discard draft",
+    "discardChangesTitle": "Discard unsaved changes?",
+    "discardChangesDescription": "This rule has edits that have not been saved. Closing the editor will lose them.",
+    "discardChanges": "Discard changes",
+    "issuesErrorHint": "Fix these before the rule can be saved. Select one to jump to it.",
+    "issuesWarningHint": "These will not block saving, but the rule may not behave as you expect.",
+    "saveBlocked_one": "Cannot save: {{count}} problem must be fixed first",
+    "saveBlocked_other": "Cannot save: {{count}} problems must be fixed first"
   },
   "panel": {
     "trigger": "Trigger Settings",
@@ -290,7 +308,11 @@
     "ariaCondition": "Condition: {{label}}",
     "ariaDelay": "Delay: {{label}}",
     "branchYes": "Yes",
-    "branchNo": "No"
+    "branchNo": "No",
+    "hasError": "Has an error",
+    "hasWarning": "Has a warning",
+    "activeFilters_one": "{{count}} active filter",
+    "activeFilters_other": "{{count}} active filters"
   },
   "ruleList": {
     "never": "Never",
@@ -311,7 +333,9 @@
     "disableRuleNamed": "Disable {{name}}",
     "openRule": "Edit {{name}}",
     "disabledBadge": "Disabled",
-    "actionNotConfigured": "Not configured"
+    "actionNotConfigured": "Not configured",
+    "misconfiguredBadge": "Incomplete",
+    "misconfiguredHint": "An action is missing a required setting, so this rule cannot run. Open it to finish setting it up."
   },
   "actionPreview": {
     "embed": "Embed: {{title}}",
@@ -355,5 +379,195 @@
       "addAction": "Add action",
       "fitView": "Fit view"
     }
+  },
+  "eventTypes": {
+    "memberJoin": {
+      "label": "Member Join",
+      "description": "When a new member joins the server"
+    },
+    "memberLeave": {
+      "label": "Member Leave",
+      "description": "When a member leaves the server"
+    },
+    "memberBanned": {
+      "label": "Member Banned",
+      "description": "When a member is banned"
+    },
+    "memberUnbanned": {
+      "label": "Member Unbanned",
+      "description": "When a member is unbanned"
+    },
+    "messageDeleted": {
+      "label": "Message Deleted",
+      "description": "When a message is deleted"
+    },
+    "roleAdded": {
+      "label": "Role Added",
+      "description": "When a role is added to a member"
+    },
+    "roleRemoved": {
+      "label": "Role Removed",
+      "description": "When a role is removed from a member"
+    },
+    "channelCreated": {
+      "label": "Channel Created",
+      "description": "When a new channel is created"
+    },
+    "channelDeleted": {
+      "label": "Channel Deleted",
+      "description": "When a channel is deleted"
+    },
+    "voiceJoin": {
+      "label": "Voice Join",
+      "description": "When a member joins a voice channel"
+    },
+    "voiceLeave": {
+      "label": "Voice Leave",
+      "description": "When a member leaves a voice channel"
+    },
+    "messageCreated": {
+      "label": "Message Created",
+      "description": "When a message is sent in a channel"
+    },
+    "reactionAdded": {
+      "label": "Reaction Added",
+      "description": "When a reaction is added to a message"
+    },
+    "reactionRemoved": {
+      "label": "Reaction Removed",
+      "description": "When a reaction is removed from a message"
+    },
+    "nicknameChanged": {
+      "label": "Nickname Changed",
+      "description": "When a member's nickname is changed"
+    },
+    "memberTimeout": {
+      "label": "Member Timeout",
+      "description": "When a member is timed out"
+    },
+    "threadCreated": {
+      "label": "Thread Created",
+      "description": "When a new thread is created"
+    },
+    "boostStart": {
+      "label": "Boost Start",
+      "description": "When a member starts boosting the server"
+    },
+    "boostEnd": {
+      "label": "Boost End",
+      "description": "When a member stops boosting the server"
+    }
+  },
+  "actionTypes": {
+    "sendMessage": {
+      "label": "Send Message",
+      "description": "Send a message to a channel"
+    },
+    "sendEmbed": {
+      "label": "Send Embed",
+      "description": "Send an embed to a channel"
+    },
+    "sendDM": {
+      "label": "Send DM",
+      "description": "Send a direct message to the user"
+    },
+    "addRole": {
+      "label": "Add Role",
+      "description": "Add a role to the member"
+    },
+    "removeRole": {
+      "label": "Remove Role",
+      "description": "Remove a role from the member"
+    },
+    "logToChannel": {
+      "label": "Log to Channel",
+      "description": "Log event details to a channel"
+    },
+    "sendWebhook": {
+      "label": "Send Webhook",
+      "description": "Send an HTTP request to an external URL"
+    },
+    "setNickname": {
+      "label": "Set Nickname",
+      "description": "Set the member's nickname"
+    },
+    "createThread": {
+      "label": "Create Thread",
+      "description": "Create a new thread in the channel"
+    },
+    "addReaction": {
+      "label": "Add Reaction",
+      "description": "Add a reaction to the triggering message"
+    }
+  },
+  "actionFields": {
+    "sendMessage_channelId": {
+      "label": "Channel"
+    },
+    "sendMessage_message": {
+      "label": "Message",
+      "placeholder": "Use {user}, {channel}, etc."
+    },
+    "sendEmbed_channelId": {
+      "label": "Channel"
+    },
+    "sendEmbed_embed_title": {
+      "label": "Embed Title",
+      "placeholder": "Embed title..."
+    },
+    "sendEmbed_embed_description": {
+      "label": "Embed Description",
+      "placeholder": "Embed description... supports {user}, {channel}, etc."
+    },
+    "sendEmbed_embed_color": {
+      "label": "Embed Color"
+    },
+    "sendEmbed_embed_footer": {
+      "label": "Embed Footer",
+      "placeholder": "Footer text..."
+    },
+    "sendDM_message": {
+      "label": "Message",
+      "placeholder": "DM message... supports {user}, {guild}, etc."
+    },
+    "addRole_roleId": {
+      "label": "Role"
+    },
+    "removeRole_roleId": {
+      "label": "Role"
+    },
+    "logToChannel_channelId": {
+      "label": "Channel"
+    },
+    "sendWebhook_webhook_url": {
+      "label": "Webhook URL",
+      "placeholder": "https://..."
+    },
+    "sendWebhook_webhook_method": {
+      "label": "HTTP Method"
+    },
+    "sendWebhook_webhook_headers": {
+      "label": "Headers (JSON)",
+      "placeholder": "{\"X-Request-Id\": \"abc\"}"
+    },
+    "sendWebhook_webhook_bodyTemplate": {
+      "label": "Body Template",
+      "placeholder": "JSON body... supports {user}, {channel}, etc."
+    },
+    "setNickname_nickname": {
+      "label": "Nickname",
+      "placeholder": "New nickname... supports {user.name}"
+    },
+    "createThread_channelId": {
+      "label": "Channel"
+    },
+    "createThread_threadName": {
+      "label": "Thread Name",
+      "placeholder": "Thread name... supports {user.name}, etc."
+    },
+    "addReaction_emoji": {
+      "label": "Emoji",
+      "placeholder": "Unicode emoji or custom emoji ID"
+    }
   }
 }
diff --git a/packages/i18n/src/locales/es/common.json b/packages/i18n/src/locales/es/common.json
index dd7140b7..0f9946f9 100644
--- a/packages/i18n/src/locales/es/common.json
+++ b/packages/i18n/src/locales/es/common.json
@@ -90,7 +90,9 @@
     "saving": "Guardando...",
     "saveSettings": "Guardar ajustes",
     "previous": "Anterior",
-    "next": "Siguiente"
+    "next": "Siguiente",
+    "invalidJson": "JSON no válido: se espera un objeto de valores de texto",
+    "fieldRequired": "{{field}} es obligatorio"
   },
   "pagination": {
     "previous": "Anterior",
diff --git a/packages/i18n/src/locales/es/rules.json b/packages/i18n/src/locales/es/rules.json
index f726da72..a7a68403 100644
--- a/packages/i18n/src/locales/es/rules.json
+++ b/packages/i18n/src/locales/es/rules.json
@@ -146,7 +146,18 @@
     "include": "Incluir (lista blanca)",
     "exclude": "Excluir (lista negra)",
     "clearAll": "Limpiar todas las condiciones",
-    "removeItem": "Quitar {{label}}"
+    "removeItem": "Quitar {{label}}",
+    "collapse": "Contraer condiciones",
+    "userIdInvalid": "Introduce un ID de usuario de Discord válido (17–20 dígitos)",
+    "addUserId": "Añadir ID de usuario",
+    "includeChannels": "Solo en estos canales",
+    "includeRoles": "Solo miembros con estos roles",
+    "includeUsers": "Solo estos miembros",
+    "excludeChannels": "Nunca en estos canales",
+    "excludeRoles": "Nunca miembros con estos roles",
+    "excludeUsers": "Nunca estos miembros",
+    "unsupportedWarning": "Este activador no puede evaluar estos filtros ({{filters}}), por lo que la regla nunca se ejecutará mientras estén definidos.",
+    "removeUnsupported": "Eliminar los filtros que no se pueden aplicar"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Ajustar vista"
     },
     "issues_one": "{{count}} problema",
-    "issues_other": "{{count}} problemas"
+    "issues_other": "{{count}} problemas",
+    "discardChangesTitle": "¿Descartar los cambios sin guardar?",
+    "discardChangesDescription": "Esta regla tiene cambios que no se han guardado. Si cierras el editor, se perderán.",
+    "discardChanges": "Descartar cambios",
+    "draftRestored": "Borrador restaurado de una sesión anterior",
+    "discardDraftAction": "Descartar borrador",
+    "discardTitle": "¿Descartar los cambios?",
+    "discardDescription": "Tienes cambios sin guardar. Tu borrador se guarda localmente, pero saldrás del editor.",
+    "discardConfirm": "Descartar y cerrar"
   },
   "panel": {
     "trigger": "Ajustes del disparador",
@@ -322,5 +341,83 @@
     "stepUnreachable": "El paso \"{{id}}\" no es accesible desde el disparador",
     "noActionType": "{{label}}: no se seleccionó ningún tipo de acción",
     "fieldRequired": "{{label}}: {{field}} es obligatorio"
+  },
+  "eventTypes": {
+    "memberJoin": {
+      "label": "Entrada de miembro",
+      "description": "Cuando un nuevo miembro entra al servidor"
+    },
+    "memberLeave": {
+      "label": "Salida de miembro",
+      "description": "Cuando un miembro sale del servidor"
+    },
+    "memberBanned": {
+      "label": "Miembro baneado",
+      "description": "Cuando se banea a un miembro"
+    },
+    "memberUnbanned": {
+      "label": "Miembro desbaneado",
+      "description": "Cuando se desbanea a un miembro"
+    },
+    "messageDeleted": {
+      "label": "Mensaje eliminado",
+      "description": "Cuando se elimina un mensaje"
+    },
+    "roleAdded": {
+      "label": "Rol añadido",
+      "description": "Cuando se añade un rol a un miembro"
+    },
+    "roleRemoved": {
+      "label": "Rol eliminado",
+      "description": "Cuando se quita un rol a un miembro"
+    },
+    "channelCreated": {
+      "label": "Canal creado",
+      "description": "Cuando se crea un canal nuevo"
+    },
+    "channelDeleted": {
+      "label": "Canal eliminado",
+      "description": "Cuando se elimina un canal"
+    },
+    "voiceJoin": {
+      "label": "Entrada a voz",
+      "description": "Cuando un miembro entra a un canal de voz"
+    },
+    "voiceLeave": {
+      "label": "Salida de voz",
+      "description": "Cuando un miembro sale de un canal de voz"
+    },
+    "messageCreated": {
+      "label": "Mensaje enviado",
+      "description": "Cuando se envía un mensaje en un canal"
+    },
+    "reactionAdded": {
+      "label": "Reacción añadida",
+      "description": "Cuando se añade una reacción a un mensaje"
+    },
+    "reactionRemoved": {
+      "label": "Reacción eliminada",
+      "description": "Cuando se quita una reacción de un mensaje"
+    },
+    "nicknameChanged": {
+      "label": "Apodo cambiado",
+      "description": "Cuando cambia el apodo de un miembro"
+    },
+    "memberTimeout": {
+      "label": "Miembro silenciado",
+      "description": "Cuando se silencia a un miembro"
+    },
+    "threadCreated": {
+      "label": "Hilo creado",
+      "description": "Cuando se crea un hilo nuevo"
+    },
+    "boostStart": {
+      "label": "Inicio de mejora",
+      "description": "Cuando un miembro empieza a mejorar el servidor"
+    },
+    "boostEnd": {
+      "label": "Fin de mejora",
+      "description": "Cuando un miembro deja de mejorar el servidor"
+    }
   }
 }
diff --git a/packages/i18n/src/locales/et/common.json b/packages/i18n/src/locales/et/common.json
index cd21bed7..c4c3bb26 100644
--- a/packages/i18n/src/locales/et/common.json
+++ b/packages/i18n/src/locales/et/common.json
@@ -90,7 +90,9 @@
     "saving": "Salvestamine...",
     "saveSettings": "Salvesta seaded",
     "previous": "Eelmine",
-    "next": "Järgmine"
+    "next": "Järgmine",
+    "invalidJson": "Vigane JSON — oodati tekstiväärtuste objekti",
+    "fieldRequired": "{{field}} on kohustuslik"
   },
   "pagination": {
     "previous": "Eelmine",
diff --git a/packages/i18n/src/locales/et/rules.json b/packages/i18n/src/locales/et/rules.json
index 3f66125b..53b29780 100644
--- a/packages/i18n/src/locales/et/rules.json
+++ b/packages/i18n/src/locales/et/rules.json
@@ -146,7 +146,18 @@
     "include": "Kaasa (valge nimekiri)",
     "exclude": "Välista (must nimekiri)",
     "clearAll": "Tühjenda kõik tingimused",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "Eemalda {{label}}",
+    "collapse": "Ahenda tingimused",
+    "userIdInvalid": "Sisesta kehtiv Discordi kasutaja ID (17–20 numbrit)",
+    "addUserId": "Lisa kasutaja ID",
+    "includeChannels": "Ainult nendes kanalites",
+    "includeRoles": "Ainult nende rollidega liikmed",
+    "includeUsers": "Ainult need liikmed",
+    "excludeChannels": "Mitte kunagi nendes kanalites",
+    "excludeRoles": "Mitte kunagi nende rollidega liikmed",
+    "excludeUsers": "Mitte kunagi need liikmed",
+    "unsupportedWarning": "See päästik ei suuda neid filtreid ({{filters}}) hinnata, seega reegel ei käivitu kunagi, kuni need on määratud.",
+    "removeUnsupported": "Eemalda filtrid, mida ei saa rakendada"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "Kas loobuda salvestamata muudatustest?",
+    "discardChangesDescription": "Sellel reeglil on salvestamata muudatusi. Redaktori sulgemisel lähevad need kaotsi.",
+    "discardChanges": "Loobu muudatustest",
+    "draftRestored": "Mustand taastati eelmisest seansist",
+    "discardDraftAction": "Loobu mustandist",
+    "discardTitle": "Kas loobuda muudatustest?",
+    "discardDescription": "Sul on salvestamata muudatusi. Mustand salvestatakse kohalikult, kuid lahkud redaktorist.",
+    "discardConfirm": "Loobu ja sulge"
   },
   "panel": {
     "trigger": "Trigger Settings",
@@ -322,5 +341,83 @@
     "stepUnreachable": "Step \"{{id}}\" is not reachable from the trigger",
     "noActionType": "{{label}}: no action type selected",
     "fieldRequired": "{{label}}: {{field}} is required"
+  },
+  "eventTypes": {
+    "memberJoin": {
+      "label": "Liige liitus",
+      "description": "Kui uus liige liitub serveriga"
+    },
+    "memberLeave": {
+      "label": "Liige lahkus",
+      "description": "Kui liige lahkub serverist"
+    },
+    "memberBanned": {
+      "label": "Liige bännitud",
+      "description": "Kui liige bännitakse"
+    },
+    "memberUnbanned": {
+      "label": "Bänn eemaldatud",
+      "description": "Kui liikme bänn eemaldatakse"
+    },
+    "messageDeleted": {
+      "label": "Sõnum kustutatud",
+      "description": "Kui sõnum kustutatakse"
+    },
+    "roleAdded": {
+      "label": "Roll lisatud",
+      "description": "Kui liikmele lisatakse roll"
+    },
+    "roleRemoved": {
+      "label": "Roll eemaldatud",
+      "description": "Kui liikmelt eemaldatakse roll"
+    },
+    "channelCreated": {
+      "label": "Kanal loodud",
+      "description": "Kui luuakse uus kanal"
+    },
+    "channelDeleted": {
+      "label": "Kanal kustutatud",
+      "description": "Kui kanal kustutatakse"
+    },
+    "voiceJoin": {
+      "label": "Liitus häälkanaliga",
+      "description": "Kui liige liitub häälkanaliga"
+    },
+    "voiceLeave": {
+      "label": "Lahkus häälkanalist",
+      "description": "Kui liige lahkub häälkanalist"
+    },
+    "messageCreated": {
+      "label": "Sõnum saadetud",
+      "description": "Kui kanalisse saadetakse sõnum"
+    },
+    "reactionAdded": {
+      "label": "Reaktsioon lisatud",
+      "description": "Kui sõnumile lisatakse reaktsioon"
+    },
+    "reactionRemoved": {
+      "label": "Reaktsioon eemaldatud",
+      "description": "Kui sõnumilt eemaldatakse reaktsioon"
+    },
+    "nicknameChanged": {
+      "label": "Hüüdnimi muudetud",
+      "description": "Kui liikme hüüdnime muudetakse"
+    },
+    "memberTimeout": {
+      "label": "Liige vaigistatud",
+      "description": "Kui liige vaigistatakse"
+    },
+    "threadCreated": {
+      "label": "Lõim loodud",
+      "description": "Kui luuakse uus lõim"
+    },
+    "boostStart": {
+      "label": "Boost algas",
+      "description": "Kui liige hakkab serverit boostima"
+    },
+    "boostEnd": {
+      "label": "Boost lõppes",
+      "description": "Kui liige lõpetab serveri boostimise"
+    }
   }
 }
diff --git a/packages/i18n/src/locales/eu/common.json b/packages/i18n/src/locales/eu/common.json
index cd4f2302..c57d2779 100644
--- a/packages/i18n/src/locales/eu/common.json
+++ b/packages/i18n/src/locales/eu/common.json
@@ -90,7 +90,9 @@
     "saving": "Gordetzen...",
     "saveSettings": "Ezarpenak gorde",
     "previous": "Aurrekoa",
-    "next": "Hurrengoa"
+    "next": "Hurrengoa",
+    "invalidJson": "JSON baliogabea — testu-balioen objektu bat espero da",
+    "fieldRequired": "{{field}} beharrezkoa da"
   },
   "pagination": {
     "previous": "Aurrekoa",
diff --git a/packages/i18n/src/locales/eu/rules.json b/packages/i18n/src/locales/eu/rules.json
index dfcebd5a..1464adac 100644
--- a/packages/i18n/src/locales/eu/rules.json
+++ b/packages/i18n/src/locales/eu/rules.json
@@ -146,7 +146,18 @@
     "include": "Barne hartu (zerrenda zuria)",
     "exclude": "Baztertu (zerrenda beltza)",
     "clearAll": "Baldintza guztiak garbitu",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "Kendu {{label}}",
+    "collapse": "Tolestu baldintzak",
+    "userIdInvalid": "Sartu baliozko Discord erabiltzaile ID bat (17–20 digitu)",
+    "addUserId": "Gehitu erabiltzaile IDa",
+    "includeChannels": "Kanal hauetan bakarrik",
+    "includeRoles": "Rol hauek dituzten kideak bakarrik",
+    "includeUsers": "Kide hauek bakarrik",
+    "excludeChannels": "Inoiz ez kanal hauetan",
+    "excludeRoles": "Inoiz ez rol hauek dituzten kideak",
+    "excludeUsers": "Inoiz ez kide hauek",
+    "unsupportedWarning": "Abiarazle honek ezin ditu iragazki hauek ({{filters}}) ebaluatu, beraz araua ez da inoiz exekutatuko ezarrita dauden bitartean.",
+    "removeUnsupported": "Kendu aplikatu ezin diren iragazkiak"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "Gorde gabeko aldaketak baztertu?",
+    "discardChangesDescription": "Arau honek gorde gabeko aldaketak ditu. Editorea ixten baduzu, galdu egingo dira.",
+    "discardChanges": "Baztertu aldaketak",
+    "draftRestored": "Zirriborroa aurreko saio batetik berreskuratu da",
+    "discardDraftAction": "Baztertu zirriborroa",
+    "discardTitle": "Aldaketak baztertu?",
+    "discardDescription": "Gorde gabeko aldaketak dituzu. Zirriborroa lokalean gordetzen da, baina editoretik aterako zara.",
+    "discardConfirm": "Baztertu eta itxi"
   },
   "panel": {
     "trigger": "Trigger Settings",
@@ -322,5 +341,83 @@
     "stepUnreachable": "Step \"{{id}}\" is not reachable from the trigger",
     "noActionType": "{{label}}: no action type selected",
     "fieldRequired": "{{label}}: {{field}} is required"
+  },
+  "eventTypes": {
+    "memberJoin": {
+      "label": "Kidea sartu da",
+      "description": "Kide berri bat zerbitzarira sartzen denean"
+    },
+    "memberLeave": {
+      "label": "Kidea atera da",
+      "description": "Kide bat zerbitzaritik ateratzen denean"
+    },
+    "memberBanned": {
+      "label": "Kidea debekatuta",
+      "description": "Kide bat debekatzen denean"
+    },
+    "memberUnbanned": {
+      "label": "Debekua kenduta",
+      "description": "Kide baten debekua kentzen denean"
+    },
+    "messageDeleted": {
+      "label": "Mezua ezabatuta",
+      "description": "Mezu bat ezabatzen denean"
+    },
+    "roleAdded": {
+      "label": "Rola gehituta",
+      "description": "Kide bati rol bat gehitzen zaionean"
+    },
+    "roleRemoved": {
+      "label": "Rola kenduta",
+      "description": "Kide bati rol bat kentzen zaionean"
+    },
+    "channelCreated": {
+      "label": "Kanala sortuta",
+      "description": "Kanal berri bat sortzen denean"
+    },
+    "channelDeleted": {
+      "label": "Kanala ezabatuta",
+      "description": "Kanal bat ezabatzen denean"
+    },
+    "voiceJoin": {
+      "label": "Ahotsera sartu",
+      "description": "Kide bat ahots-kanal batera sartzen denean"
+    },
+    "voiceLeave": {
+      "label": "Ahotsetik atera",
+      "description": "Kide bat ahots-kanal batetik ateratzen denean"
+    },
+    "messageCreated": {
+      "label": "Mezua bidalita",
+      "description": "Kanal batean mezu bat bidaltzen denean"
+    },
+    "reactionAdded": {
+      "label": "Erreakzioa gehituta",
+      "description": "Mezu bati erreakzio bat gehitzen zaionean"
+    },
+    "reactionRemoved": {
+      "label": "Erreakzioa kenduta",
+      "description": "Mezu bati erreakzio bat kentzen zaionean"
+    },
+    "nicknameChanged": {
+      "label": "Ezizena aldatuta",
+      "description": "Kide baten ezizena aldatzen denean"
+    },
+    "memberTimeout": {
+      "label": "Kidea isilarazita",
+      "description": "Kide bat isilarazten denean"
+    },
+    "threadCreated": {
+      "label": "Haria sortuta",
+      "description": "Hari berri bat sortzen denean"
+    },
+    "boostStart": {
+      "label": "Bultzada hasi da",
+      "description": "Kide batek zerbitzaria bultzatzen hasten denean"
+    },
+    "boostEnd": {
+      "label": "Bultzada amaitu da",
+      "description": "Kide batek zerbitzaria bultzatzeari uzten dionean"
+    }
   }
 }
diff --git a/packages/i18n/src/locales/fa/common.json b/packages/i18n/src/locales/fa/common.json
index 5dd824cf..af5d7a5d 100644
--- a/packages/i18n/src/locales/fa/common.json
+++ b/packages/i18n/src/locales/fa/common.json
@@ -90,7 +90,9 @@
     "saving": "در حال ذخیره...",
     "saveSettings": "ذخیره تنظیمات",
     "previous": "قبلی",
-    "next": "بعدی"
+    "next": "بعدی",
+    "invalidJson": "JSON معتبر نیست — یک شیء از مقادیر متنی انتظار می‌رود",
+    "fieldRequired": "{{field}} الزامی است"
   },
   "pagination": {
     "previous": "قبلی",
diff --git a/packages/i18n/src/locales/fa/rules.json b/packages/i18n/src/locales/fa/rules.json
index 0f782e7d..a6e764b3 100644
--- a/packages/i18n/src/locales/fa/rules.json
+++ b/packages/i18n/src/locales/fa/rules.json
@@ -146,7 +146,18 @@
     "include": "شامل‌کردن (فهرست سفید)",
     "exclude": "حذف (فهرست سیاه)",
     "clearAll": "پاک کردن همه شرایط",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "حذف {{label}}",
+    "collapse": "جمع کردن شرط‌ها",
+    "userIdInvalid": "یک شناسه کاربری معتبر Discord وارد کنید (۱۷ تا ۲۰ رقم)",
+    "addUserId": "افزودن شناسه کاربر",
+    "includeChannels": "فقط در این کانال‌ها",
+    "includeRoles": "فقط اعضای دارای این نقش‌ها",
+    "includeUsers": "فقط این اعضا",
+    "excludeChannels": "هرگز در این کانال‌ها",
+    "excludeRoles": "هرگز اعضای دارای این نقش‌ها",
+    "excludeUsers": "هرگز این اعضا",
+    "unsupportedWarning": "این راه‌انداز نمی‌تواند این فیلترها ({{filters}}) را ارزیابی کند، بنابراین تا زمانی که تنظیم شده باشند قانون هرگز اجرا نمی‌شود.",
+    "removeUnsupported": "حذف فیلترهایی که قابل اعمال نیستند"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "تغییرات ذخیره‌نشده کنار گذاشته شود؟",
+    "discardChangesDescription": "این قانون تغییراتی دارد که ذخیره نشده‌اند. با بستن ویرایشگر از بین می‌روند.",
+    "discardChanges": "کنار گذاشتن تغییرات",
+    "draftRestored": "پیش‌نویس از جلسه قبلی بازیابی شد",
+    "discardDraftAction": "کنار گذاشتن پیش‌نویس",
+    "discardTitle": "تغییرات کنار گذاشته شود؟",
+    "discardDescription": "تغییرات ذخیره‌نشده دارید. پیش‌نویس شما به‌صورت محلی ذخیره می‌شود، اما از ویرایشگر خارج می‌شوید.",
+    "discardConfirm": "کنار گذاشتن و بستن"
   },
   "panel": {
     "trigger": "Trigger Settings",
@@ -322,5 +341,83 @@
     "stepUnreachable": "Step \"{{id}}\" is not reachable from the trigger",
     "noActionType": "{{label}}: no action type selected",
     "fieldRequired": "{{label}}: {{field}} is required"
+  },
+  "eventTypes": {
+    "memberJoin": {
+      "label": "پیوستن عضو",
+      "description": "وقتی عضو جدیدی به سرور می‌پیوندد"
+    },
+    "memberLeave": {
+      "label": "خروج عضو",
+      "description": "وقتی عضوی سرور را ترک می‌کند"
+    },
+    "memberBanned": {
+      "label": "مسدود شدن عضو",
+      "description": "وقتی عضوی مسدود می‌شود"
+    },
+    "memberUnbanned": {
+      "label": "رفع مسدودیت عضو",
+      "description": "وقتی مسدودیت عضوی برداشته می‌شود"
+    },
+    "messageDeleted": {
+      "label": "حذف پیام",
+      "description": "وقتی پیامی حذف می‌شود"
+    },
+    "roleAdded": {
+      "label": "افزودن نقش",
+      "description": "وقتی نقشی به عضوی افزوده می‌شود"
+    },
+    "roleRemoved": {
+      "label": "حذف نقش",
+      "description": "وقتی نقشی از عضوی حذف می‌شود"
+    },
+    "channelCreated": {
+      "label": "ایجاد کانال",
+      "description": "وقتی کانال جدیدی ایجاد می‌شود"
+    },
+    "channelDeleted": {
+      "label": "حذف کانال",
+      "description": "وقتی کانالی حذف می‌شود"
+    },
+    "voiceJoin": {
+      "label": "پیوستن به صوتی",
+      "description": "وقتی عضوی به کانال صوتی می‌پیوندد"
+    },
+    "voiceLeave": {
+      "label": "خروج از صوتی",
+      "description": "وقتی عضوی کانال صوتی را ترک می‌کند"
+    },
+    "messageCreated": {
+      "label": "ارسال پیام",
+      "description": "وقتی پیامی در کانالی ارسال می‌شود"
+    },
+    "reactionAdded": {
+      "label": "افزودن واکنش",
+      "description": "وقتی واکنشی به پیامی افزوده می‌شود"
+    },
+    "reactionRemoved": {
+      "label": "حذف واکنش",
+      "description": "وقتی واکنشی از پیامی حذف می‌شود"
+    },
+    "nicknameChanged": {
+      "label": "تغییر نام مستعار",
+      "description": "وقتی نام مستعار عضوی تغییر می‌کند"
+    },
+    "memberTimeout": {
+      "label": "سکوت عضو",
+      "description": "وقتی عضوی ساکت می‌شود"
+    },
+    "threadCreated": {
+      "label": "ایجاد رشته",
+      "description": "وقتی رشته جدیدی ایجاد می‌شود"
+    },
+    "boostStart": {
+      "label": "شروع بوست",
+      "description": "وقتی عضوی شروع به بوست کردن سرور می‌کند"
+    },
+    "boostEnd": {
+      "label": "پایان بوست",
+      "description": "وقتی عضوی بوست کردن سرور را متوقف می‌کند"
+    }
   }
 }
diff --git a/packages/i18n/src/locales/fi/common.json b/packages/i18n/src/locales/fi/common.json
index 9b3717e6..2e408aa4 100644
--- a/packages/i18n/src/locales/fi/common.json
+++ b/packages/i18n/src/locales/fi/common.json
@@ -90,7 +90,9 @@
     "saving": "Tallennetaan...",
     "saveSettings": "Tallenna asetukset",
     "previous": "Edellinen",
-    "next": "Seuraava"
+    "next": "Seuraava",
+    "invalidJson": "Virheellinen JSON — odotettiin objektia, jossa on tekstiarvoja",
+    "fieldRequired": "{{field}} on pakollinen"
   },
   "pagination": {
     "previous": "Edellinen",
diff --git a/packages/i18n/src/locales/fi/rules.json b/packages/i18n/src/locales/fi/rules.json
index c38be2c6..86b64ab4 100644
--- a/packages/i18n/src/locales/fi/rules.json
+++ b/packages/i18n/src/locales/fi/rules.json
@@ -146,7 +146,18 @@
     "include": "Sisällytä (valkolista)",
     "exclude": "Sulje pois (mustat lista)",
     "clearAll": "Tyhjennä kaikki ehdot",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "Poista {{label}}",
+    "collapse": "Tiivistä ehdot",
+    "userIdInvalid": "Anna kelvollinen Discord-käyttäjätunnus (17–20 numeroa)",
+    "addUserId": "Lisää käyttäjätunnus",
+    "includeChannels": "Vain näissä kanavissa",
+    "includeRoles": "Vain jäsenet, joilla on nämä roolit",
+    "includeUsers": "Vain nämä jäsenet",
+    "excludeChannels": "Ei koskaan näissä kanavissa",
+    "excludeRoles": "Ei koskaan jäsenet, joilla on nämä roolit",
+    "excludeUsers": "Ei koskaan nämä jäsenet",
+    "unsupportedWarning": "Tämä liipaisin ei voi arvioida näitä suodattimia ({{filters}}), joten sääntö ei koskaan laukea niin kauan kuin ne on asetettu.",
+    "removeUnsupported": "Poista suodattimet, joita ei voi soveltaa"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "Hylätäänkö tallentamattomat muutokset?",
+    "discardChangesDescription": "Tässä säännössä on tallentamattomia muutoksia. Editorin sulkeminen hävittää ne.",
+    "discardChanges": "Hylkää muutokset",
+    "draftRestored": "Luonnos palautettu aiemmasta istunnosta",
+    "discardDraftAction": "Hylkää luonnos",
+    "discardTitle": "Hylätäänkö muutokset?",
+    "discardDescription": "Sinulla on tallentamattomia muutoksia. Luonnos tallennetaan paikallisesti, mutta poistut editorista.",
+    "discardConfirm": "Hylkää ja sulje"
   },
   "panel": {
     "trigger": "Trigger Settings",
@@ -322,5 +341,83 @@
     "stepUnreachable": "Step \"{{id}}\" is not reachable from the trigger",
     "noActionType": "{{label}}: no action type selected",
     "fieldRequired": "{{label}}: {{field}} is required"
+  },
+  "eventTypes": {
+    "memberJoin": {
+      "label": "Jäsen liittyi",
+      "description": "Kun uusi jäsen liittyy palvelimelle"
+    },
+    "memberLeave": {
+      "label": "Jäsen poistui",
+      "description": "Kun jäsen poistuu palvelimelta"
+    },
+    "memberBanned": {
+      "label": "Jäsen porttikiellossa",
+      "description": "Kun jäsen asetetaan porttikieltoon"
+    },
+    "memberUnbanned": {
+      "label": "Porttikielto poistettu",
+      "description": "Kun jäsenen porttikielto poistetaan"
+    },
+    "messageDeleted": {
+      "label": "Viesti poistettu",
+      "description": "Kun viesti poistetaan"
+    },
+    "roleAdded": {
+      "label": "Rooli lisätty",
+      "description": "Kun jäsenelle lisätään rooli"
+    },
+    "roleRemoved": {
+      "label": "Rooli poistettu",
+      "description": "Kun jäseneltä poistetaan rooli"
+    },
+    "channelCreated": {
+      "label": "Kanava luotu",
+      "description": "Kun luodaan uusi kanava"
+    },
+    "channelDeleted": {
+      "label": "Kanava poistettu",
+      "description": "Kun kanava poistetaan"
+    },
+    "voiceJoin": {
+      "label": "Liittyi puhekanavaan",
+      "description": "Kun jäsen liittyy puhekanavalle"
+    },
+    "voiceLeave": {
+      "label": "Poistui puhekanavalta",
+      "description": "Kun jäsen poistuu puhekanavalta"
+    },
+    "messageCreated": {
+      "label": "Viesti lähetetty",
+      "description": "Kun kanavalle lähetetään viesti"
+    },
+    "reactionAdded": {
+      "label": "Reaktio lisätty",
+      "description": "Kun viestiin lisätään reaktio"
+    },
+    "reactionRemoved": {
+      "label": "Reaktio poistettu",
+      "description": "Kun viestistä poistetaan reaktio"
+    },
+    "nicknameChanged": {
+      "label": "Kutsumanimi vaihdettu",
+      "description": "Kun jäsenen kutsumanimi vaihdetaan"
+    },
+    "memberTimeout": {
+      "label": "Jäsen hiljennetty",
+      "description": "Kun jäsen hiljennetään"
+    },
+    "threadCreated": {
+      "label": "Ketju luotu",
+      "description": "Kun luodaan uusi ketju"
+    },
+    "boostStart": {
+      "label": "Tehostus alkoi",
+      "description": "Kun jäsen alkaa tehostaa palvelinta"
+    },
+    "boostEnd": {
+      "label": "Tehostus päättyi",
+      "description": "Kun jäsen lopettaa palvelimen tehostamisen"
+    }
   }
 }
diff --git a/packages/i18n/src/locales/fil/common.json b/packages/i18n/src/locales/fil/common.json
index 66aad148..1f9146d5 100644
--- a/packages/i18n/src/locales/fil/common.json
+++ b/packages/i18n/src/locales/fil/common.json
@@ -90,7 +90,9 @@
     "saving": "Nag-se-save...",
     "saveSettings": "I-save ang Mga Setting",
     "previous": "Nakaraan",
-    "next": "Susunod"
+    "next": "Susunod",
+    "invalidJson": "Hindi wastong JSON — inaasahan ang isang object ng mga text value",
+    "fieldRequired": "Kailangan ang {{field}}"
   },
   "pagination": {
     "previous": "Nakaraan",
diff --git a/packages/i18n/src/locales/fil/rules.json b/packages/i18n/src/locales/fil/rules.json
index 9ab8872f..4a09c247 100644
--- a/packages/i18n/src/locales/fil/rules.json
+++ b/packages/i18n/src/locales/fil/rules.json
@@ -146,7 +146,18 @@
     "include": "Isama (whitelist)",
     "exclude": "I-exclude (blacklist)",
     "clearAll": "I-clear ang lahat ng kondisyon",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "Alisin ang {{label}}",
+    "collapse": "I-collapse ang mga kundisyon",
+    "userIdInvalid": "Maglagay ng wastong Discord user ID (17–20 digit)",
+    "addUserId": "Magdagdag ng user ID",
+    "includeChannels": "Sa mga channel na ito lamang",
+    "includeRoles": "Mga miyembro lamang na may ganitong role",
+    "includeUsers": "Ang mga miyembrong ito lamang",
+    "excludeChannels": "Hindi kailanman sa mga channel na ito",
+    "excludeRoles": "Hindi kailanman ang mga miyembrong may ganitong role",
+    "excludeUsers": "Hindi kailanman ang mga miyembrong ito",
+    "unsupportedWarning": "Hindi masusuri ng trigger na ito ang mga filter na ito ({{filters}}), kaya hindi kailanman tatakbo ang panuntunan habang nakatakda ang mga ito.",
+    "removeUnsupported": "Alisin ang mga filter na hindi maaaring ilapat"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "Itapon ang mga hindi na-save na pagbabago?",
+    "discardChangesDescription": "May mga pagbabago ang panuntunang ito na hindi pa na-save. Mawawala ang mga ito kapag isinara ang editor.",
+    "discardChanges": "Itapon ang mga pagbabago",
+    "draftRestored": "Naibalik ang draft mula sa nakaraang session",
+    "discardDraftAction": "Itapon ang draft",
+    "discardTitle": "Itapon ang mga pagbabago?",
+    "discardDescription": "May mga hindi na-save na pagbabago ka. Naka-save nang lokal ang draft mo, pero aalis ka sa editor.",
+    "discardConfirm": "Itapon at isara"
   },
   "panel": {
     "trigger": "Trigger Settings",
@@ -322,5 +341,83 @@
     "stepUnreachable": "Step \"{{id}}\" is not reachable from the trigger",
     "noActionType": "{{label}}: no action type selected",
     "fieldRequired": "{{label}}: {{field}} is required"
+  },
+  "eventTypes": {
+    "memberJoin": {
+      "label": "Sumali ang miyembro",
+      "description": "Kapag sumali ang bagong miyembro sa server"
+    },
+    "memberLeave": {
+      "label": "Umalis ang miyembro",
+      "description": "Kapag umalis ang miyembro sa server"
+    },
+    "memberBanned": {
+      "label": "Na-ban ang miyembro",
+      "description": "Kapag na-ban ang miyembro"
+    },
+    "memberUnbanned": {
+      "label": "Na-unban ang miyembro",
+      "description": "Kapag na-unban ang miyembro"
+    },
+    "messageDeleted": {
+      "label": "Natanggal na mensahe",
+      "description": "Kapag natanggal ang mensahe"
+    },
+    "roleAdded": {
+      "label": "Naidagdag na role",
+      "description": "Kapag naidagdag ang role sa miyembro"
+    },
+    "roleRemoved": {
+      "label": "Natanggal na role",
+      "description": "Kapag natanggal ang role sa miyembro"
+    },
+    "channelCreated": {
+      "label": "Nagawang channel",
+      "description": "Kapag nagawa ang bagong channel"
+    },
+    "channelDeleted": {
+      "label": "Natanggal na channel",
+      "description": "Kapag natanggal ang channel"
+    },
+    "voiceJoin": {
+      "label": "Sumali sa voice",
+      "description": "Kapag sumali ang miyembro sa voice channel"
+    },
+    "voiceLeave": {
+      "label": "Umalis sa voice",
+      "description": "Kapag umalis ang miyembro sa voice channel"
+    },
+    "messageCreated": {
+      "label": "Naipadalang mensahe",
+      "description": "Kapag may naipadalang mensahe sa channel"
+    },
+    "reactionAdded": {
+      "label": "Naidagdag na reaction",
+      "description": "Kapag naidagdag ang reaction sa mensahe"
+    },
+    "reactionRemoved": {
+      "label": "Natanggal na reaction",
+      "description": "Kapag natanggal ang reaction sa mensahe"
+    },
+    "nicknameChanged": {
+      "label": "Nabagong palayaw",
+      "description": "Kapag nabago ang palayaw ng miyembro"
+    },
+    "memberTimeout": {
+      "label": "Na-timeout na miyembro",
+      "description": "Kapag na-timeout ang miyembro"
+    },
+    "threadCreated": {
+      "label": "Nagawang thread",
+      "description": "Kapag nagawa ang bagong thread"
+    },
+    "boostStart": {
+      "label": "Nagsimula ang boost",
+      "description": "Kapag sinimulan ng miyembro ang pag-boost sa server"
+    },
+    "boostEnd": {
+      "label": "Natapos ang boost",
+      "description": "Kapag itinigil ng miyembro ang pag-boost sa server"
+    }
   }
 }
diff --git a/packages/i18n/src/locales/fr/common.json b/packages/i18n/src/locales/fr/common.json
index 62f0b795..85185874 100644
--- a/packages/i18n/src/locales/fr/common.json
+++ b/packages/i18n/src/locales/fr/common.json
@@ -90,7 +90,9 @@
     "saving": "Enregistrement...",
     "saveSettings": "Enregistrer les paramètres",
     "previous": "Précédent",
-    "next": "Suivant"
+    "next": "Suivant",
+    "invalidJson": "JSON non valide — un objet de valeurs texte est attendu",
+    "fieldRequired": "{{field}} est obligatoire"
   },
   "pagination": {
     "previous": "Précédent",
diff --git a/packages/i18n/src/locales/fr/rules.json b/packages/i18n/src/locales/fr/rules.json
index d32d7e0f..a458af07 100644
--- a/packages/i18n/src/locales/fr/rules.json
+++ b/packages/i18n/src/locales/fr/rules.json
@@ -146,7 +146,18 @@
     "include": "Inclure (liste blanche)",
     "exclude": "Exclure (liste noire)",
     "clearAll": "Effacer toutes les conditions",
-    "removeItem": "Retirer {{label}}"
+    "removeItem": "Retirer {{label}}",
+    "collapse": "Réduire les conditions",
+    "userIdInvalid": "Saisissez un identifiant utilisateur Discord valide (17 à 20 chiffres)",
+    "addUserId": "Ajouter un identifiant utilisateur",
+    "includeChannels": "Uniquement dans ces salons",
+    "includeRoles": "Uniquement les membres ayant ces rôles",
+    "includeUsers": "Uniquement ces membres",
+    "excludeChannels": "Jamais dans ces salons",
+    "excludeRoles": "Jamais les membres ayant ces rôles",
+    "excludeUsers": "Jamais ces membres",
+    "unsupportedWarning": "Ce déclencheur ne peut pas évaluer ces filtres ({{filters}}) ; la règle ne se déclenchera donc jamais tant qu'ils sont définis.",
+    "removeUnsupported": "Supprimer les filtres inapplicables"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Ajuster la vue"
     },
     "issues_one": "{{count}} problème",
-    "issues_other": "{{count}} problèmes"
+    "issues_other": "{{count}} problèmes",
+    "discardChangesTitle": "Abandonner les modifications non enregistrées ?",
+    "discardChangesDescription": "Cette règle comporte des modifications non enregistrées. Fermer l'éditeur les perdra.",
+    "discardChanges": "Abandonner les modifications",
+    "draftRestored": "Brouillon restauré d'une session précédente",
+    "discardDraftAction": "Abandonner le brouillon",
+    "discardTitle": "Abandonner les modifications ?",
+    "discardDescription": "Vous avez des modifications non enregistrées. Votre brouillon est enregistré localement, mais vous quitterez l'éditeur.",
+    "discardConfirm": "Abandonner et fermer"
   },
   "panel": {
     "trigger": "Paramètres du déclencheur",
@@ -322,5 +341,83 @@
     "stepUnreachable": "L'étape « {{id}} » n'est pas accessible depuis le déclencheur",
     "noActionType": "{{label}} : aucun type d'action sélectionné",
     "fieldRequired": "{{label}} : {{field}} est requis"
+  },
+  "eventTypes": {
+    "memberJoin": {
+      "label": "Arrivée d'un membre",
+      "description": "Lorsqu'un nouveau membre rejoint le serveur"
+    },
+    "memberLeave": {
+      "label": "Départ d'un membre",
+      "description": "Lorsqu'un membre quitte le serveur"
+    },
+    "memberBanned": {
+      "label": "Membre banni",
+      "description": "Lorsqu'un membre est banni"
+    },
+    "memberUnbanned": {
+      "label": "Membre débanni",
+      "description": "Lorsqu'un membre est débanni"
+    },
+    "messageDeleted": {
+      "label": "Message supprimé",
+      "description": "Lorsqu'un message est supprimé"
+    },
+    "roleAdded": {
+      "label": "Rôle ajouté",
+      "description": "Lorsqu'un rôle est ajouté à un membre"
+    },
+    "roleRemoved": {
+      "label": "Rôle retiré",
+      "description": "Lorsqu'un rôle est retiré à un membre"
+    },
+    "channelCreated": {
+      "label": "Salon créé",
+      "description": "Lorsqu'un nouveau salon est créé"
+    },
+    "channelDeleted": {
+      "label": "Salon supprimé",
+      "description": "Lorsqu'un salon est supprimé"
+    },
+    "voiceJoin": {
+      "label": "Connexion vocale",
+      "description": "Lorsqu'un membre rejoint un salon vocal"
+    },
+    "voiceLeave": {
+      "label": "Déconnexion vocale",
+      "description": "Lorsqu'un membre quitte un salon vocal"
+    },
+    "messageCreated": {
+      "label": "Message envoyé",
+      "description": "Lorsqu'un message est envoyé dans un salon"
+    },
+    "reactionAdded": {
+      "label": "Réaction ajoutée",
+      "description": "Lorsqu'une réaction est ajoutée à un message"
+    },
+    "reactionRemoved": {
+      "label": "Réaction retirée",
+      "description": "Lorsqu'une réaction est retirée d'un message"
+    },
+    "nicknameChanged": {
+      "label": "Surnom modifié",
+      "description": "Lorsque le surnom d'un membre est modifié"
+    },
+    "memberTimeout": {
+      "label": "Membre exclu temporairement",
+      "description": "Lorsqu'un membre est exclu temporairement"
+    },
+    "threadCreated": {
+      "label": "Fil créé",
+      "description": "Lorsqu'un nouveau fil est créé"
+    },
+    "boostStart": {
+      "label": "Début de boost",
+      "description": "Lorsqu'un membre commence à booster le serveur"
+    },
+    "boostEnd": {
+      "label": "Fin de boost",
+      "description": "Lorsqu'un membre arrête de booster le serveur"
+    }
   }
 }
diff --git a/packages/i18n/src/locales/gl/common.json b/packages/i18n/src/locales/gl/common.json
index 72556b06..68d8ef42 100644
--- a/packages/i18n/src/locales/gl/common.json
+++ b/packages/i18n/src/locales/gl/common.json
@@ -90,7 +90,9 @@
     "saving": "Gardando...",
     "saveSettings": "Gardar configuración",
     "previous": "Anterior",
-    "next": "Seguinte"
+    "next": "Seguinte",
+    "invalidJson": "JSON non válido: espérase un obxecto de valores de texto",
+    "fieldRequired": "{{field}} é obrigatorio"
   },
   "pagination": {
     "previous": "Anterior",
diff --git a/packages/i18n/src/locales/gl/rules.json b/packages/i18n/src/locales/gl/rules.json
index 82ec0a3e..792fc9f4 100644
--- a/packages/i18n/src/locales/gl/rules.json
+++ b/packages/i18n/src/locales/gl/rules.json
@@ -146,7 +146,18 @@
     "include": "Incluír (lista branca)",
     "exclude": "Excluír (lista negra)",
     "clearAll": "Limpar todas as condicións",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "Eliminar {{label}}",
+    "collapse": "Contraer condicións",
+    "userIdInvalid": "Introduce un ID de usuario de Discord válido (17–20 díxitos)",
+    "addUserId": "Engadir ID de usuario",
+    "includeChannels": "Só nestas canles",
+    "includeRoles": "Só membros con estes roles",
+    "includeUsers": "Só estes membros",
+    "excludeChannels": "Nunca nestas canles",
+    "excludeRoles": "Nunca membros con estes roles",
+    "excludeUsers": "Nunca estes membros",
+    "unsupportedWarning": "Este activador non pode avaliar estes filtros ({{filters}}), polo que a regra nunca se executará mentres estean definidos.",
+    "removeUnsupported": "Eliminar os filtros que non se poden aplicar"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "Descartar os cambios sen gardar?",
+    "discardChangesDescription": "Esta regra ten cambios que non se gardaron. Se pechas o editor, perderanse.",
+    "discardChanges": "Descartar cambios",
+    "draftRestored": "Borrador restaurado dunha sesión anterior",
+    "discardDraftAction": "Descartar borrador",
+    "discardTitle": "Descartar os cambios?",
+    "discardDescription": "Tes cambios sen gardar. O teu borrador gárdase localmente, pero sairás do editor.",
+    "discardConfirm": "Descartar e pechar"
   },
   "panel": {
     "trigger": "Trigger Settings",
diff --git a/packages/i18n/src/locales/he/common.json b/packages/i18n/src/locales/he/common.json
index f925522f..c4560489 100644
--- a/packages/i18n/src/locales/he/common.json
+++ b/packages/i18n/src/locales/he/common.json
@@ -90,7 +90,9 @@
     "saving": "שומר...",
     "saveSettings": "שמור הגדרות",
     "previous": "הקודם",
-    "next": "הבא"
+    "next": "הבא",
+    "invalidJson": "JSON לא תקין — נדרש אובייקט של ערכי טקסט",
+    "fieldRequired": "{{field}} הוא שדה חובה"
   },
   "pagination": {
     "previous": "הקודם",
diff --git a/packages/i18n/src/locales/he/rules.json b/packages/i18n/src/locales/he/rules.json
index 15451ce0..9880aec2 100644
--- a/packages/i18n/src/locales/he/rules.json
+++ b/packages/i18n/src/locales/he/rules.json
@@ -146,7 +146,18 @@
     "include": "כלול (רשימה לבנה)",
     "exclude": "אל תכלול (רשימה שחורה)",
     "clearAll": "נקה את כל התנאים",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "הסר את {{label}}",
+    "collapse": "כווץ תנאים",
+    "userIdInvalid": "הזן מזהה משתמש Discord תקין (17–20 ספרות)",
+    "addUserId": "הוסף מזהה משתמש",
+    "includeChannels": "רק בערוצים אלה",
+    "includeRoles": "רק חברים עם תפקידים אלה",
+    "includeUsers": "רק חברים אלה",
+    "excludeChannels": "אף פעם בערוצים אלה",
+    "excludeRoles": "אף פעם חברים עם תפקידים אלה",
+    "excludeUsers": "אף פעם חברים אלה",
+    "unsupportedWarning": "טריגר זה אינו יכול להעריך את המסננים האלה ({{filters}}), ולכן הכלל לעולם לא יופעל כל עוד הם מוגדרים.",
+    "removeUnsupported": "הסר מסננים שאינם ישימים"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "לבטל שינויים שלא נשמרו?",
+    "discardChangesDescription": "לכלל הזה יש שינויים שלא נשמרו. סגירת העורך תמחק אותם.",
+    "discardChanges": "בטל שינויים",
+    "draftRestored": "טיוטה שוחזרה מהפעלה קודמת",
+    "discardDraftAction": "בטל טיוטה",
+    "discardTitle": "לבטל שינויים?",
+    "discardDescription": "יש לך שינויים שלא נשמרו. הטיוטה נשמרת מקומית, אך תצא מהעורך.",
+    "discardConfirm": "בטל וסגור"
   },
   "panel": {
     "trigger": "Trigger Settings",
diff --git a/packages/i18n/src/locales/hi/common.json b/packages/i18n/src/locales/hi/common.json
index d23552c8..8c0b4f0c 100644
--- a/packages/i18n/src/locales/hi/common.json
+++ b/packages/i18n/src/locales/hi/common.json
@@ -90,7 +90,9 @@
     "saving": "सहेजा जा रहा है...",
     "saveSettings": "सेटिंग्स सहेजें",
     "previous": "पिछला",
-    "next": "अगला"
+    "next": "अगला",
+    "invalidJson": "मान्य JSON नहीं — टेक्स्ट मानों वाला ऑब्जेक्ट अपेक्षित",
+    "fieldRequired": "{{field}} आवश्यक है"
   },
   "pagination": {
     "previous": "पिछला",
diff --git a/packages/i18n/src/locales/hi/rules.json b/packages/i18n/src/locales/hi/rules.json
index 76c15953..ea8c5f19 100644
--- a/packages/i18n/src/locales/hi/rules.json
+++ b/packages/i18n/src/locales/hi/rules.json
@@ -146,7 +146,18 @@
     "include": "शामिल करें (व्हाइटलिस्ट)",
     "exclude": "बाहर करें (ब्लैकलिस्ट)",
     "clearAll": "सभी शर्तें साफ़ करें",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "{{label}} हटाएँ",
+    "collapse": "शर्तें संक्षिप्त करें",
+    "userIdInvalid": "मान्य Discord उपयोगकर्ता आईडी दर्ज करें (17–20 अंक)",
+    "addUserId": "उपयोगकर्ता आईडी जोड़ें",
+    "includeChannels": "केवल इन चैनलों में",
+    "includeRoles": "केवल इन भूमिकाओं वाले सदस्य",
+    "includeUsers": "केवल ये सदस्य",
+    "excludeChannels": "कभी भी इन चैनलों में नहीं",
+    "excludeRoles": "कभी भी इन भूमिकाओं वाले सदस्य नहीं",
+    "excludeUsers": "कभी भी ये सदस्य नहीं",
+    "unsupportedWarning": "यह ट्रिगर इन फ़िल्टर ({{filters}}) का मूल्यांकन नहीं कर सकता, इसलिए जब तक वे सेट हैं नियम कभी नहीं चलेगा।",
+    "removeUnsupported": "जो फ़िल्टर लागू नहीं हो सकते उन्हें हटाएँ"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "सहेजे न गए बदलाव छोड़ें?",
+    "discardChangesDescription": "इस नियम में ऐसे बदलाव हैं जो सहेजे नहीं गए। संपादक बंद करने पर वे खो जाएँगे।",
+    "discardChanges": "बदलाव छोड़ें",
+    "draftRestored": "पिछले सत्र से ड्राफ़्ट पुनर्स्थापित किया गया",
+    "discardDraftAction": "ड्राफ़्ट छोड़ें",
+    "discardTitle": "बदलाव छोड़ें?",
+    "discardDescription": "आपके पास सहेजे न गए बदलाव हैं। आपका ड्राफ़्ट स्थानीय रूप से सहेजा गया है, पर आप संपादक छोड़ देंगे।",
+    "discardConfirm": "छोड़ें और बंद करें"
   },
   "panel": {
     "trigger": "Trigger Settings",
diff --git a/packages/i18n/src/locales/hr/common.json b/packages/i18n/src/locales/hr/common.json
index 26bfc786..e49e683f 100644
--- a/packages/i18n/src/locales/hr/common.json
+++ b/packages/i18n/src/locales/hr/common.json
@@ -90,7 +90,9 @@
     "saving": "Spremanje...",
     "saveSettings": "Spremi postavke",
     "previous": "Prethodna",
-    "next": "Sljedeća"
+    "next": "Sljedeća",
+    "invalidJson": "Nevažeći JSON — očekuje se objekt tekstualnih vrijednosti",
+    "fieldRequired": "{{field}} je obavezno"
   },
   "pagination": {
     "previous": "Prethodna",
diff --git a/packages/i18n/src/locales/hr/rules.json b/packages/i18n/src/locales/hr/rules.json
index c88d2993..ea17a289 100644
--- a/packages/i18n/src/locales/hr/rules.json
+++ b/packages/i18n/src/locales/hr/rules.json
@@ -146,7 +146,18 @@
     "include": "Uključi (bijela lista)",
     "exclude": "Isključi (crna lista)",
     "clearAll": "Obriši sve uvjete",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "Ukloni {{label}}",
+    "collapse": "Sažmi uvjete",
+    "userIdInvalid": "Unesite valjani Discord korisnički ID (17–20 znamenki)",
+    "addUserId": "Dodaj korisnički ID",
+    "includeChannels": "Samo u ovim kanalima",
+    "includeRoles": "Samo članovi s ovim ulogama",
+    "includeUsers": "Samo ovi članovi",
+    "excludeChannels": "Nikada u ovim kanalima",
+    "excludeRoles": "Nikada članovi s ovim ulogama",
+    "excludeUsers": "Nikada ovi članovi",
+    "unsupportedWarning": "Ovaj okidač ne može procijeniti ove filtre ({{filters}}), pa se pravilo nikada neće pokrenuti dok su postavljeni.",
+    "removeUnsupported": "Ukloni filtre koji se ne mogu primijeniti"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "Odbaciti nespremljene promjene?",
+    "discardChangesDescription": "Ovo pravilo ima promjene koje nisu spremljene. Zatvaranjem uređivača bit će izgubljene.",
+    "discardChanges": "Odbaci promjene",
+    "draftRestored": "Skica vraćena iz prethodne sesije",
+    "discardDraftAction": "Odbaci skicu",
+    "discardTitle": "Odbaciti promjene?",
+    "discardDescription": "Imate nespremljene promjene. Skica se sprema lokalno, ali napustit ćete uređivač.",
+    "discardConfirm": "Odbaci i zatvori"
   },
   "panel": {
     "trigger": "Trigger Settings",
diff --git a/packages/i18n/src/locales/hu/common.json b/packages/i18n/src/locales/hu/common.json
index 6ffd6a37..ae03b411 100644
--- a/packages/i18n/src/locales/hu/common.json
+++ b/packages/i18n/src/locales/hu/common.json
@@ -90,7 +90,9 @@
     "saving": "Mentés...",
     "saveSettings": "Beállítások mentése",
     "previous": "Előző",
-    "next": "Következő"
+    "next": "Következő",
+    "invalidJson": "Érvénytelen JSON — szöveges értékekből álló objektum szükséges",
+    "fieldRequired": "A(z) {{field}} megadása kötelező"
   },
   "pagination": {
     "previous": "Előző",
diff --git a/packages/i18n/src/locales/hu/rules.json b/packages/i18n/src/locales/hu/rules.json
index f5fb5185..0d390407 100644
--- a/packages/i18n/src/locales/hu/rules.json
+++ b/packages/i18n/src/locales/hu/rules.json
@@ -146,7 +146,18 @@
     "include": "Belefoglalás (fehérlista)",
     "exclude": "Kizárás (feketelista)",
     "clearAll": "Összes feltétel törlése",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "{{label}} eltávolítása",
+    "collapse": "Feltételek összecsukása",
+    "userIdInvalid": "Adjon meg érvényes Discord felhasználói azonosítót (17–20 számjegy)",
+    "addUserId": "Felhasználói azonosító hozzáadása",
+    "includeChannels": "Csak ezekben a csatornákban",
+    "includeRoles": "Csak az ilyen szerepkörű tagok",
+    "includeUsers": "Csak ezek a tagok",
+    "excludeChannels": "Soha ezekben a csatornákban",
+    "excludeRoles": "Soha az ilyen szerepkörű tagok",
+    "excludeUsers": "Soha ezek a tagok",
+    "unsupportedWarning": "Ez az eseményindító nem tudja kiértékelni ezeket a szűrőket ({{filters}}), ezért a szabály soha nem fut le, amíg be vannak állítva.",
+    "removeUnsupported": "Nem alkalmazható szűrők eltávolítása"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "Elveti a nem mentett módosításokat?",
+    "discardChangesDescription": "Ez a szabály nem mentett módosításokat tartalmaz. A szerkesztő bezárásával elvesznek.",
+    "discardChanges": "Módosítások elvetése",
+    "draftRestored": "Piszkozat visszaállítva egy korábbi munkamenetből",
+    "discardDraftAction": "Piszkozat elvetése",
+    "discardTitle": "Elveti a módosításokat?",
+    "discardDescription": "Nem mentett módosításai vannak. A piszkozat helyben mentve marad, de elhagyja a szerkesztőt.",
+    "discardConfirm": "Elvetés és bezárás"
   },
   "panel": {
     "trigger": "Trigger Settings",
diff --git a/packages/i18n/src/locales/id/common.json b/packages/i18n/src/locales/id/common.json
index 0123dbcb..aa9794c9 100644
--- a/packages/i18n/src/locales/id/common.json
+++ b/packages/i18n/src/locales/id/common.json
@@ -90,7 +90,9 @@
     "saving": "Menyimpan...",
     "saveSettings": "Simpan Pengaturan",
     "previous": "Sebelumnya",
-    "next": "Berikutnya"
+    "next": "Berikutnya",
+    "invalidJson": "JSON tidak valid — diharapkan objek berisi nilai teks",
+    "fieldRequired": "{{field}} wajib diisi"
   },
   "pagination": {
     "previous": "Sebelumnya",
diff --git a/packages/i18n/src/locales/id/rules.json b/packages/i18n/src/locales/id/rules.json
index 5db08b8d..09dd8e2d 100644
--- a/packages/i18n/src/locales/id/rules.json
+++ b/packages/i18n/src/locales/id/rules.json
@@ -146,7 +146,18 @@
     "include": "Sertakan (daftar putih)",
     "exclude": "Kecualikan (daftar hitam)",
     "clearAll": "Hapus semua kondisi",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "Hapus {{label}}",
+    "collapse": "Ciutkan kondisi",
+    "userIdInvalid": "Masukkan ID pengguna Discord yang valid (17–20 digit)",
+    "addUserId": "Tambahkan ID pengguna",
+    "includeChannels": "Hanya di kanal ini",
+    "includeRoles": "Hanya anggota dengan peran ini",
+    "includeUsers": "Hanya anggota ini",
+    "excludeChannels": "Tidak pernah di kanal ini",
+    "excludeRoles": "Tidak pernah anggota dengan peran ini",
+    "excludeUsers": "Tidak pernah anggota ini",
+    "unsupportedWarning": "Pemicu ini tidak dapat mengevaluasi filter ini ({{filters}}), sehingga aturan tidak akan pernah berjalan selama filter tersebut disetel.",
+    "removeUnsupported": "Hapus filter yang tidak dapat diterapkan"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "Buang perubahan yang belum disimpan?",
+    "discardChangesDescription": "Aturan ini memiliki perubahan yang belum disimpan. Menutup editor akan menghilangkannya.",
+    "discardChanges": "Buang perubahan",
+    "draftRestored": "Draf dipulihkan dari sesi sebelumnya",
+    "discardDraftAction": "Buang draf",
+    "discardTitle": "Buang perubahan?",
+    "discardDescription": "Anda memiliki perubahan yang belum disimpan. Draf tersimpan secara lokal, tetapi Anda akan keluar dari editor.",
+    "discardConfirm": "Buang & tutup"
   },
   "panel": {
     "trigger": "Trigger Settings",
diff --git a/packages/i18n/src/locales/it/common.json b/packages/i18n/src/locales/it/common.json
index 93a296b4..c6760315 100644
--- a/packages/i18n/src/locales/it/common.json
+++ b/packages/i18n/src/locales/it/common.json
@@ -90,7 +90,9 @@
     "saving": "Salvataggio...",
     "saveSettings": "Salva impostazioni",
     "previous": "Precedente",
-    "next": "Successivo"
+    "next": "Successivo",
+    "invalidJson": "JSON non valido: è previsto un oggetto di valori di testo",
+    "fieldRequired": "{{field}} è obbligatorio"
   },
   "pagination": {
     "previous": "Precedente",
diff --git a/packages/i18n/src/locales/it/rules.json b/packages/i18n/src/locales/it/rules.json
index 6ee65a7e..431dcfc3 100644
--- a/packages/i18n/src/locales/it/rules.json
+++ b/packages/i18n/src/locales/it/rules.json
@@ -146,7 +146,18 @@
     "include": "Includi (whitelist)",
     "exclude": "Escludi (blacklist)",
     "clearAll": "Cancella tutte le condizioni",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "Rimuovi {{label}}",
+    "collapse": "Comprimi condizioni",
+    "userIdInvalid": "Inserisci un ID utente Discord valido (17–20 cifre)",
+    "addUserId": "Aggiungi ID utente",
+    "includeChannels": "Solo in questi canali",
+    "includeRoles": "Solo membri con questi ruoli",
+    "includeUsers": "Solo questi membri",
+    "excludeChannels": "Mai in questi canali",
+    "excludeRoles": "Mai membri con questi ruoli",
+    "excludeUsers": "Mai questi membri",
+    "unsupportedWarning": "Questo trigger non può valutare questi filtri ({{filters}}), quindi la regola non verrà mai eseguita finché sono impostati.",
+    "removeUnsupported": "Rimuovi i filtri non applicabili"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "Ignorare le modifiche non salvate?",
+    "discardChangesDescription": "Questa regola ha modifiche non salvate. Chiudendo l'editor andranno perse.",
+    "discardChanges": "Ignora le modifiche",
+    "draftRestored": "Bozza ripristinata da una sessione precedente",
+    "discardDraftAction": "Ignora bozza",
+    "discardTitle": "Ignorare le modifiche?",
+    "discardDescription": "Hai modifiche non salvate. La bozza viene salvata localmente, ma uscirai dall'editor.",
+    "discardConfirm": "Ignora e chiudi"
   },
   "panel": {
     "trigger": "Trigger Settings",
diff --git a/packages/i18n/src/locales/ja/common.json b/packages/i18n/src/locales/ja/common.json
index 4d034725..b5b736e8 100644
--- a/packages/i18n/src/locales/ja/common.json
+++ b/packages/i18n/src/locales/ja/common.json
@@ -90,7 +90,9 @@
     "saving": "保存中...",
     "saveSettings": "設定を保存",
     "previous": "前へ",
-    "next": "次へ"
+    "next": "次へ",
+    "invalidJson": "有効な JSON ではありません — 文字列値のオブジェクトが必要です",
+    "fieldRequired": "{{field}} は必須です"
   },
   "pagination": {
     "previous": "前へ",
diff --git a/packages/i18n/src/locales/ja/rules.json b/packages/i18n/src/locales/ja/rules.json
index 57d73fde..44a947ec 100644
--- a/packages/i18n/src/locales/ja/rules.json
+++ b/packages/i18n/src/locales/ja/rules.json
@@ -146,7 +146,18 @@
     "include": "含める（ホワイトリスト）",
     "exclude": "除外する（ブラックリスト）",
     "clearAll": "すべての条件をクリア",
-    "removeItem": "{{label}}を削除"
+    "removeItem": "{{label}}を削除",
+    "collapse": "条件を折りたたむ",
+    "userIdInvalid": "有効な Discord ユーザー ID を入力してください（17〜20 桁）",
+    "addUserId": "ユーザー ID を追加",
+    "includeChannels": "これらのチャンネルのみ",
+    "includeRoles": "これらのロールを持つメンバーのみ",
+    "includeUsers": "これらのメンバーのみ",
+    "excludeChannels": "これらのチャンネルでは実行しない",
+    "excludeRoles": "これらのロールを持つメンバーでは実行しない",
+    "excludeUsers": "これらのメンバーでは実行しない",
+    "unsupportedWarning": "このトリガーはこれらのフィルター（{{filters}}）を評価できないため、設定されている間ルールは実行されません。",
+    "removeUnsupported": "適用できないフィルターを削除"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "画面に合わせる"
     },
     "issues_one": "{{count}}件の問題",
-    "issues_other": "{{count}}件の問題"
+    "issues_other": "{{count}}件の問題",
+    "discardChangesTitle": "保存していない変更を破棄しますか？",
+    "discardChangesDescription": "このルールには保存されていない変更があります。エディターを閉じると失われます。",
+    "discardChanges": "変更を破棄",
+    "draftRestored": "前回のセッションから下書きを復元しました",
+    "discardDraftAction": "下書きを破棄",
+    "discardTitle": "変更を破棄しますか？",
+    "discardDescription": "保存していない変更があります。下書きはローカルに保存されますが、エディターを離れます。",
+    "discardConfirm": "破棄して閉じる"
   },
   "panel": {
     "trigger": "トリガー設定",
diff --git a/packages/i18n/src/locales/ko/common.json b/packages/i18n/src/locales/ko/common.json
index 284ad870..37301dc1 100644
--- a/packages/i18n/src/locales/ko/common.json
+++ b/packages/i18n/src/locales/ko/common.json
@@ -90,7 +90,9 @@
     "saving": "저장 중...",
     "saveSettings": "설정 저장",
     "previous": "이전",
-    "next": "다음"
+    "next": "다음",
+    "invalidJson": "유효한 JSON이 아닙니다 — 문자열 값 객체가 필요합니다",
+    "fieldRequired": "{{field}}은(는) 필수입니다"
   },
   "pagination": {
     "previous": "이전",
diff --git a/packages/i18n/src/locales/ko/rules.json b/packages/i18n/src/locales/ko/rules.json
index eee7c0f7..58f83121 100644
--- a/packages/i18n/src/locales/ko/rules.json
+++ b/packages/i18n/src/locales/ko/rules.json
@@ -146,7 +146,18 @@
     "include": "포함 (화이트리스트)",
     "exclude": "제외 (블랙리스트)",
     "clearAll": "모든 조건 초기화",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "{{label}} 제거",
+    "collapse": "조건 접기",
+    "userIdInvalid": "유효한 Discord 사용자 ID를 입력하세요 (17~20자리)",
+    "addUserId": "사용자 ID 추가",
+    "includeChannels": "이 채널에서만",
+    "includeRoles": "이 역할을 가진 멤버만",
+    "includeUsers": "이 멤버만",
+    "excludeChannels": "이 채널에서는 제외",
+    "excludeRoles": "이 역할을 가진 멤버 제외",
+    "excludeUsers": "이 멤버 제외",
+    "unsupportedWarning": "이 트리거는 이 필터({{filters}})를 평가할 수 없으므로 필터가 설정되어 있는 동안 규칙이 실행되지 않습니다.",
+    "removeUnsupported": "적용할 수 없는 필터 제거"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "저장하지 않은 변경사항을 삭제할까요?",
+    "discardChangesDescription": "이 규칙에는 저장되지 않은 변경사항이 있습니다. 편집기를 닫으면 사라집니다.",
+    "discardChanges": "변경사항 삭제",
+    "draftRestored": "이전 세션의 임시 저장본을 복원했습니다",
+    "discardDraftAction": "임시 저장본 삭제",
+    "discardTitle": "변경사항을 삭제할까요?",
+    "discardDescription": "저장하지 않은 변경사항이 있습니다. 임시 저장본은 로컬에 남지만 편집기를 벗어납니다.",
+    "discardConfirm": "삭제하고 닫기"
   },
   "panel": {
     "trigger": "Trigger Settings",
diff --git a/packages/i18n/src/locales/lt/common.json b/packages/i18n/src/locales/lt/common.json
index b35bd1ca..eef0ac6c 100644
--- a/packages/i18n/src/locales/lt/common.json
+++ b/packages/i18n/src/locales/lt/common.json
@@ -90,7 +90,9 @@
     "saving": "Saugoma...",
     "saveSettings": "Išsaugoti nustatymus",
     "previous": "Ankstesnis",
-    "next": "Kitas"
+    "next": "Kitas",
+    "invalidJson": "Netinkamas JSON — tikimasi teksto reikšmių objekto",
+    "fieldRequired": "{{field}} yra privalomas"
   },
   "pagination": {
     "previous": "Ankstesnis",
diff --git a/packages/i18n/src/locales/lt/rules.json b/packages/i18n/src/locales/lt/rules.json
index 340929cf..8b8d7ce2 100644
--- a/packages/i18n/src/locales/lt/rules.json
+++ b/packages/i18n/src/locales/lt/rules.json
@@ -146,7 +146,18 @@
     "include": "Įtraukti (baltasis sąrašas)",
     "exclude": "Neįtraukti (juodasis sąrašas)",
     "clearAll": "Išvalyti visas sąlygas",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "Pašalinti {{label}}",
+    "collapse": "Suskleisti sąlygas",
+    "userIdInvalid": "Įveskite galiojantį Discord naudotojo ID (17–20 skaitmenų)",
+    "addUserId": "Pridėti naudotojo ID",
+    "includeChannels": "Tik šiuose kanaluose",
+    "includeRoles": "Tik nariai su šiais vaidmenimis",
+    "includeUsers": "Tik šie nariai",
+    "excludeChannels": "Niekada šiuose kanaluose",
+    "excludeRoles": "Niekada nariai su šiais vaidmenimis",
+    "excludeUsers": "Niekada šie nariai",
+    "unsupportedWarning": "Šis paleidiklis negali įvertinti šių filtrų ({{filters}}), todėl taisyklė niekada nebus vykdoma, kol jie nustatyti.",
+    "removeUnsupported": "Pašalinti filtrus, kurių negalima pritaikyti"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "Atmesti neįrašytus pakeitimus?",
+    "discardChangesDescription": "Ši taisyklė turi neįrašytų pakeitimų. Uždarius rengyklę jie bus prarasti.",
+    "discardChanges": "Atmesti pakeitimus",
+    "draftRestored": "Juodraštis atkurtas iš ankstesnės sesijos",
+    "discardDraftAction": "Atmesti juodraštį",
+    "discardTitle": "Atmesti pakeitimus?",
+    "discardDescription": "Turite neįrašytų pakeitimų. Juodraštis įrašomas vietoje, bet paliksite rengyklę.",
+    "discardConfirm": "Atmesti ir uždaryti"
   },
   "panel": {
     "trigger": "Trigger Settings",
diff --git a/packages/i18n/src/locales/lv/common.json b/packages/i18n/src/locales/lv/common.json
index 4818d729..4af64084 100644
--- a/packages/i18n/src/locales/lv/common.json
+++ b/packages/i18n/src/locales/lv/common.json
@@ -90,7 +90,9 @@
     "saving": "Saglabā...",
     "saveSettings": "Saglabāt iestatījumus",
     "previous": "Iepriekšējā",
-    "next": "Nākamā"
+    "next": "Nākamā",
+    "invalidJson": "Nederīgs JSON — gaidīts teksta vērtību objekts",
+    "fieldRequired": "{{field}} ir obligāts"
   },
   "pagination": {
     "previous": "Iepriekšējā",
diff --git a/packages/i18n/src/locales/lv/rules.json b/packages/i18n/src/locales/lv/rules.json
index ce2c2aca..001f8f38 100644
--- a/packages/i18n/src/locales/lv/rules.json
+++ b/packages/i18n/src/locales/lv/rules.json
@@ -146,7 +146,18 @@
     "include": "Iekļaut (baltais saraksts)",
     "exclude": "Izslēgt (melnais saraksts)",
     "clearAll": "Notīrīt visus nosacījumus",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "Noņemt {{label}}",
+    "collapse": "Sakļaut nosacījumus",
+    "userIdInvalid": "Ievadiet derīgu Discord lietotāja ID (17–20 cipari)",
+    "addUserId": "Pievienot lietotāja ID",
+    "includeChannels": "Tikai šajos kanālos",
+    "includeRoles": "Tikai dalībnieki ar šīm lomām",
+    "includeUsers": "Tikai šie dalībnieki",
+    "excludeChannels": "Nekad šajos kanālos",
+    "excludeRoles": "Nekad dalībnieki ar šīm lomām",
+    "excludeUsers": "Nekad šie dalībnieki",
+    "unsupportedWarning": "Šis aktivizētājs nevar novērtēt šos filtrus ({{filters}}), tāpēc noteikums nekad netiks izpildīts, kamēr tie ir iestatīti.",
+    "removeUnsupported": "Noņemt filtrus, kurus nevar piemērot"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "Vai atmest nesaglabātās izmaiņas?",
+    "discardChangesDescription": "Šim noteikumam ir nesaglabātas izmaiņas. Aizverot redaktoru, tās tiks zaudētas.",
+    "discardChanges": "Atmest izmaiņas",
+    "draftRestored": "Melnraksts atjaunots no iepriekšējās sesijas",
+    "discardDraftAction": "Atmest melnrakstu",
+    "discardTitle": "Vai atmest izmaiņas?",
+    "discardDescription": "Jums ir nesaglabātas izmaiņas. Melnraksts tiek saglabāts lokāli, bet jūs pametīsiet redaktoru.",
+    "discardConfirm": "Atmest un aizvērt"
   },
   "panel": {
     "trigger": "Trigger Settings",
diff --git a/packages/i18n/src/locales/ms/common.json b/packages/i18n/src/locales/ms/common.json
index 90f717f4..c4d08435 100644
--- a/packages/i18n/src/locales/ms/common.json
+++ b/packages/i18n/src/locales/ms/common.json
@@ -90,7 +90,9 @@
     "saving": "Menyimpan...",
     "saveSettings": "Simpan Tetapan",
     "previous": "Sebelumnya",
-    "next": "Seterusnya"
+    "next": "Seterusnya",
+    "invalidJson": "JSON tidak sah — objek nilai teks dijangka",
+    "fieldRequired": "{{field}} diperlukan"
   },
   "pagination": {
     "previous": "Sebelumnya",
diff --git a/packages/i18n/src/locales/ms/rules.json b/packages/i18n/src/locales/ms/rules.json
index e44edb3b..42240d5f 100644
--- a/packages/i18n/src/locales/ms/rules.json
+++ b/packages/i18n/src/locales/ms/rules.json
@@ -146,7 +146,18 @@
     "include": "Sertakan (senarai putih)",
     "exclude": "Kecualikan (senarai hitam)",
     "clearAll": "Kosongkan semua syarat",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "Buang {{label}}",
+    "collapse": "Kuncupkan syarat",
+    "userIdInvalid": "Masukkan ID pengguna Discord yang sah (17–20 digit)",
+    "addUserId": "Tambah ID pengguna",
+    "includeChannels": "Hanya dalam saluran ini",
+    "includeRoles": "Hanya ahli dengan peranan ini",
+    "includeUsers": "Hanya ahli ini",
+    "excludeChannels": "Tidak pernah dalam saluran ini",
+    "excludeRoles": "Tidak pernah ahli dengan peranan ini",
+    "excludeUsers": "Tidak pernah ahli ini",
+    "unsupportedWarning": "Pencetus ini tidak dapat menilai penapis ini ({{filters}}), jadi peraturan tidak akan berjalan selagi ia ditetapkan.",
+    "removeUnsupported": "Buang penapis yang tidak boleh digunakan"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "Buang perubahan yang belum disimpan?",
+    "discardChangesDescription": "Peraturan ini mempunyai perubahan yang belum disimpan. Menutup editor akan menghilangkannya.",
+    "discardChanges": "Buang perubahan",
+    "draftRestored": "Draf dipulihkan daripada sesi sebelumnya",
+    "discardDraftAction": "Buang draf",
+    "discardTitle": "Buang perubahan?",
+    "discardDescription": "Anda mempunyai perubahan yang belum disimpan. Draf disimpan secara setempat, tetapi anda akan meninggalkan editor.",
+    "discardConfirm": "Buang & tutup"
   },
   "panel": {
     "trigger": "Trigger Settings",
diff --git a/packages/i18n/src/locales/nl/common.json b/packages/i18n/src/locales/nl/common.json
index 7f029333..a1478f86 100644
--- a/packages/i18n/src/locales/nl/common.json
+++ b/packages/i18n/src/locales/nl/common.json
@@ -90,7 +90,9 @@
     "saving": "Opslaan...",
     "saveSettings": "Instellingen opslaan",
     "previous": "Vorige",
-    "next": "Volgende"
+    "next": "Volgende",
+    "invalidJson": "Geen geldige JSON — een object met tekstwaarden wordt verwacht",
+    "fieldRequired": "{{field}} is verplicht"
   },
   "pagination": {
     "previous": "Vorige",
diff --git a/packages/i18n/src/locales/nl/rules.json b/packages/i18n/src/locales/nl/rules.json
index 1b9ddc3e..6e797c40 100644
--- a/packages/i18n/src/locales/nl/rules.json
+++ b/packages/i18n/src/locales/nl/rules.json
@@ -146,7 +146,18 @@
     "include": "Insluiten (whitelist)",
     "exclude": "Uitsluiten (blacklist)",
     "clearAll": "Alle voorwaarden wissen",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "{{label}} verwijderen",
+    "collapse": "Voorwaarden inklappen",
+    "userIdInvalid": "Voer een geldige Discord-gebruikers-ID in (17–20 cijfers)",
+    "addUserId": "Gebruikers-ID toevoegen",
+    "includeChannels": "Alleen in deze kanalen",
+    "includeRoles": "Alleen leden met deze rollen",
+    "includeUsers": "Alleen deze leden",
+    "excludeChannels": "Nooit in deze kanalen",
+    "excludeRoles": "Nooit leden met deze rollen",
+    "excludeUsers": "Nooit deze leden",
+    "unsupportedWarning": "Deze trigger kan deze filters ({{filters}}) niet evalueren, dus de regel wordt nooit uitgevoerd zolang ze zijn ingesteld.",
+    "removeUnsupported": "Filters verwijderen die niet van toepassing kunnen zijn"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "Niet-opgeslagen wijzigingen verwijderen?",
+    "discardChangesDescription": "Deze regel heeft wijzigingen die niet zijn opgeslagen. Als je de editor sluit, gaan ze verloren.",
+    "discardChanges": "Wijzigingen verwijderen",
+    "draftRestored": "Concept hersteld uit een eerdere sessie",
+    "discardDraftAction": "Concept verwijderen",
+    "discardTitle": "Wijzigingen verwijderen?",
+    "discardDescription": "Je hebt niet-opgeslagen wijzigingen. Je concept wordt lokaal bewaard, maar je verlaat de editor.",
+    "discardConfirm": "Verwijderen en sluiten"
   },
   "panel": {
     "trigger": "Trigger Settings",
diff --git a/packages/i18n/src/locales/no/common.json b/packages/i18n/src/locales/no/common.json
index 3ba75222..a65fbb1f 100644
--- a/packages/i18n/src/locales/no/common.json
+++ b/packages/i18n/src/locales/no/common.json
@@ -90,7 +90,9 @@
     "saving": "Lagrer...",
     "saveSettings": "Lagre innstillinger",
     "previous": "Forrige",
-    "next": "Neste"
+    "next": "Neste",
+    "invalidJson": "Ikke gyldig JSON — forventet et objekt med tekstverdier",
+    "fieldRequired": "{{field}} er påkrevd"
   },
   "pagination": {
     "previous": "Forrige",
diff --git a/packages/i18n/src/locales/no/rules.json b/packages/i18n/src/locales/no/rules.json
index 2683c378..b726a0bb 100644
--- a/packages/i18n/src/locales/no/rules.json
+++ b/packages/i18n/src/locales/no/rules.json
@@ -146,7 +146,18 @@
     "include": "Inkluder (hvitliste)",
     "exclude": "Ekskluder (svarteliste)",
     "clearAll": "Tøm alle betingelser",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "Fjern {{label}}",
+    "collapse": "Skjul betingelser",
+    "userIdInvalid": "Skriv inn en gyldig Discord-bruker-ID (17–20 sifre)",
+    "addUserId": "Legg til bruker-ID",
+    "includeChannels": "Bare i disse kanalene",
+    "includeRoles": "Bare medlemmer med disse rollene",
+    "includeUsers": "Bare disse medlemmene",
+    "excludeChannels": "Aldri i disse kanalene",
+    "excludeRoles": "Aldri medlemmer med disse rollene",
+    "excludeUsers": "Aldri disse medlemmene",
+    "unsupportedWarning": "Denne utløseren kan ikke evaluere disse filtrene ({{filters}}), så regelen vil aldri kjøre så lenge de er angitt.",
+    "removeUnsupported": "Fjern filtre som ikke kan brukes"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "Forkaste ulagrede endringer?",
+    "discardChangesDescription": "Denne regelen har endringer som ikke er lagret. Hvis du lukker redigeringsprogrammet, går de tapt.",
+    "discardChanges": "Forkast endringer",
+    "draftRestored": "Utkast gjenopprettet fra en tidligere økt",
+    "discardDraftAction": "Forkast utkast",
+    "discardTitle": "Forkaste endringer?",
+    "discardDescription": "Du har ulagrede endringer. Utkastet lagres lokalt, men du forlater redigeringsprogrammet.",
+    "discardConfirm": "Forkast og lukk"
   },
   "panel": {
     "trigger": "Trigger Settings",
diff --git a/packages/i18n/src/locales/pl/common.json b/packages/i18n/src/locales/pl/common.json
index 7c6c6820..73c44db3 100644
--- a/packages/i18n/src/locales/pl/common.json
+++ b/packages/i18n/src/locales/pl/common.json
@@ -90,7 +90,9 @@
     "saving": "Zapisywanie...",
     "saveSettings": "Zapisz ustawienia",
     "previous": "Poprzednia",
-    "next": "Następna"
+    "next": "Następna",
+    "invalidJson": "Nieprawidłowy JSON — oczekiwano obiektu wartości tekstowych",
+    "fieldRequired": "Pole {{field}} jest wymagane"
   },
   "pagination": {
     "previous": "Poprzednia",
diff --git a/packages/i18n/src/locales/pl/rules.json b/packages/i18n/src/locales/pl/rules.json
index 3d5e3f0b..b351d4ca 100644
--- a/packages/i18n/src/locales/pl/rules.json
+++ b/packages/i18n/src/locales/pl/rules.json
@@ -146,7 +146,18 @@
     "include": "Dołącz (biała lista)",
     "exclude": "Wyklucz (czarna lista)",
     "clearAll": "Wyczyść wszystkie warunki",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "Usuń {{label}}",
+    "collapse": "Zwiń warunki",
+    "userIdInvalid": "Wprowadź prawidłowy identyfikator użytkownika Discord (17–20 cyfr)",
+    "addUserId": "Dodaj identyfikator użytkownika",
+    "includeChannels": "Tylko na tych kanałach",
+    "includeRoles": "Tylko członkowie z tymi rolami",
+    "includeUsers": "Tylko ci członkowie",
+    "excludeChannels": "Nigdy na tych kanałach",
+    "excludeRoles": "Nigdy członkowie z tymi rolami",
+    "excludeUsers": "Nigdy ci członkowie",
+    "unsupportedWarning": "Ten wyzwalacz nie może ocenić tych filtrów ({{filters}}), więc reguła nigdy się nie uruchomi, dopóki są ustawione.",
+    "removeUnsupported": "Usuń filtry, których nie można zastosować"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "Odrzucić niezapisane zmiany?",
+    "discardChangesDescription": "Ta reguła ma niezapisane zmiany. Zamknięcie edytora spowoduje ich utratę.",
+    "discardChanges": "Odrzuć zmiany",
+    "draftRestored": "Przywrócono wersję roboczą z poprzedniej sesji",
+    "discardDraftAction": "Odrzuć wersję roboczą",
+    "discardTitle": "Odrzucić zmiany?",
+    "discardDescription": "Masz niezapisane zmiany. Wersja robocza jest zapisywana lokalnie, ale opuścisz edytor.",
+    "discardConfirm": "Odrzuć i zamknij"
   },
   "panel": {
     "trigger": "Trigger Settings",
diff --git a/packages/i18n/src/locales/pt/common.json b/packages/i18n/src/locales/pt/common.json
index f4c953de..8d5a6edc 100644
--- a/packages/i18n/src/locales/pt/common.json
+++ b/packages/i18n/src/locales/pt/common.json
@@ -90,7 +90,9 @@
     "saving": "A guardar...",
     "saveSettings": "Guardar definições",
     "previous": "Anterior",
-    "next": "Seguinte"
+    "next": "Seguinte",
+    "invalidJson": "JSON inválido — esperava-se um objeto de valores de texto",
+    "fieldRequired": "{{field}} é obrigatório"
   },
   "pagination": {
     "previous": "Anterior",
diff --git a/packages/i18n/src/locales/pt/rules.json b/packages/i18n/src/locales/pt/rules.json
index c81d3574..0b2e93fd 100644
--- a/packages/i18n/src/locales/pt/rules.json
+++ b/packages/i18n/src/locales/pt/rules.json
@@ -146,7 +146,18 @@
     "include": "Incluir (lista branca)",
     "exclude": "Excluir (lista negra)",
     "clearAll": "Limpar todas as condições",
-    "removeItem": "Remover {{label}}"
+    "removeItem": "Remover {{label}}",
+    "collapse": "Recolher condições",
+    "userIdInvalid": "Introduza um ID de utilizador do Discord válido (17–20 dígitos)",
+    "addUserId": "Adicionar ID de utilizador",
+    "includeChannels": "Apenas nestes canais",
+    "includeRoles": "Apenas membros com estas funções",
+    "includeUsers": "Apenas estes membros",
+    "excludeChannels": "Nunca nestes canais",
+    "excludeRoles": "Nunca membros com estas funções",
+    "excludeUsers": "Nunca estes membros",
+    "unsupportedWarning": "Este acionador não consegue avaliar estes filtros ({{filters}}), pelo que a regra nunca será executada enquanto estiverem definidos.",
+    "removeUnsupported": "Remover filtros que não podem ser aplicados"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Ajustar à tela"
     },
     "issues_one": "{{count}} problema",
-    "issues_other": "{{count}} problemas"
+    "issues_other": "{{count}} problemas",
+    "discardChangesTitle": "Descartar as alterações não guardadas?",
+    "discardChangesDescription": "Esta regra tem alterações que não foram guardadas. Fechar o editor irá perdê-las.",
+    "discardChanges": "Descartar alterações",
+    "draftRestored": "Rascunho restaurado de uma sessão anterior",
+    "discardDraftAction": "Descartar rascunho",
+    "discardTitle": "Descartar as alterações?",
+    "discardDescription": "Tem alterações não guardadas. O rascunho é guardado localmente, mas vai sair do editor.",
+    "discardConfirm": "Descartar e fechar"
   },
   "panel": {
     "trigger": "Configurações do Gatilho",
diff --git a/packages/i18n/src/locales/ro/common.json b/packages/i18n/src/locales/ro/common.json
index f08509e1..2c16020b 100644
--- a/packages/i18n/src/locales/ro/common.json
+++ b/packages/i18n/src/locales/ro/common.json
@@ -90,7 +90,9 @@
     "saving": "Se salvează...",
     "saveSettings": "Salvează Setările",
     "previous": "Anterior",
-    "next": "Următor"
+    "next": "Următor",
+    "invalidJson": "JSON invalid — se așteaptă un obiect cu valori text",
+    "fieldRequired": "{{field}} este obligatoriu"
   },
   "pagination": {
     "previous": "Anterior",
diff --git a/packages/i18n/src/locales/ro/rules.json b/packages/i18n/src/locales/ro/rules.json
index 12f8a92b..43db1ab2 100644
--- a/packages/i18n/src/locales/ro/rules.json
+++ b/packages/i18n/src/locales/ro/rules.json
@@ -146,7 +146,18 @@
     "include": "Includeți (lista albă)",
     "exclude": "Excludeți (lista neagră)",
     "clearAll": "Șterge toate condițiile",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "Elimină {{label}}",
+    "collapse": "Restrânge condițiile",
+    "userIdInvalid": "Introduceți un ID de utilizator Discord valid (17–20 cifre)",
+    "addUserId": "Adăugați ID-ul utilizatorului",
+    "includeChannels": "Doar în aceste canale",
+    "includeRoles": "Doar membrii cu aceste roluri",
+    "includeUsers": "Doar acești membri",
+    "excludeChannels": "Niciodată în aceste canale",
+    "excludeRoles": "Niciodată membrii cu aceste roluri",
+    "excludeUsers": "Niciodată acești membri",
+    "unsupportedWarning": "Acest declanșator nu poate evalua aceste filtre ({{filters}}), așa că regula nu se va executa niciodată cât timp sunt setate.",
+    "removeUnsupported": "Eliminați filtrele care nu se pot aplica"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "Renunțați la modificările nesalvate?",
+    "discardChangesDescription": "Această regulă are modificări nesalvate. Închiderea editorului le va pierde.",
+    "discardChanges": "Renunță la modificări",
+    "draftRestored": "Ciornă restaurată dintr-o sesiune anterioară",
+    "discardDraftAction": "Renunță la ciornă",
+    "discardTitle": "Renunțați la modificări?",
+    "discardDescription": "Aveți modificări nesalvate. Ciorna este salvată local, dar veți părăsi editorul.",
+    "discardConfirm": "Renunță și închide"
   },
   "panel": {
     "trigger": "Trigger Settings",
diff --git a/packages/i18n/src/locales/ru/common.json b/packages/i18n/src/locales/ru/common.json
index e432e10a..8d375d21 100644
--- a/packages/i18n/src/locales/ru/common.json
+++ b/packages/i18n/src/locales/ru/common.json
@@ -90,7 +90,9 @@
     "saving": "Сохранение...",
     "saveSettings": "Сохранить настройки",
     "previous": "Назад",
-    "next": "Далее"
+    "next": "Далее",
+    "invalidJson": "Некорректный JSON — ожидается объект текстовых значений",
+    "fieldRequired": "Поле «{{field}}» обязательно"
   },
   "pagination": {
     "previous": "Назад",
diff --git a/packages/i18n/src/locales/ru/rules.json b/packages/i18n/src/locales/ru/rules.json
index 37cb2f0b..6c263186 100644
--- a/packages/i18n/src/locales/ru/rules.json
+++ b/packages/i18n/src/locales/ru/rules.json
@@ -146,7 +146,18 @@
     "include": "Включить (белый список)",
     "exclude": "Исключить (чёрный список)",
     "clearAll": "Очистить все условия",
-    "removeItem": "Удалить {{label}}"
+    "removeItem": "Удалить {{label}}",
+    "collapse": "Свернуть условия",
+    "userIdInvalid": "Введите действительный идентификатор пользователя Discord (17–20 цифр)",
+    "addUserId": "Добавить идентификатор пользователя",
+    "includeChannels": "Только в этих каналах",
+    "includeRoles": "Только участники с этими ролями",
+    "includeUsers": "Только эти участники",
+    "excludeChannels": "Никогда в этих каналах",
+    "excludeRoles": "Никогда участники с этими ролями",
+    "excludeUsers": "Никогда эти участники",
+    "unsupportedWarning": "Этот триггер не может вычислить эти фильтры ({{filters}}), поэтому правило никогда не сработает, пока они заданы.",
+    "removeUnsupported": "Удалить фильтры, которые невозможно применить"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "По размеру"
     },
     "issues_one": "{{count}} проблема",
-    "issues_other": "{{count}} проблем"
+    "issues_other": "{{count}} проблем",
+    "discardChangesTitle": "Отменить несохранённые изменения?",
+    "discardChangesDescription": "В этом правиле есть несохранённые изменения. При закрытии редактора они будут потеряны.",
+    "discardChanges": "Отменить изменения",
+    "draftRestored": "Черновик восстановлен из предыдущего сеанса",
+    "discardDraftAction": "Отменить черновик",
+    "discardTitle": "Отменить изменения?",
+    "discardDescription": "Есть несохранённые изменения. Черновик сохраняется локально, но вы покинете редактор.",
+    "discardConfirm": "Отменить и закрыть"
   },
   "panel": {
     "trigger": "Настройки триггера",
diff --git a/packages/i18n/src/locales/sk/common.json b/packages/i18n/src/locales/sk/common.json
index f8f5126a..66e8559e 100644
--- a/packages/i18n/src/locales/sk/common.json
+++ b/packages/i18n/src/locales/sk/common.json
@@ -90,7 +90,9 @@
     "saving": "Ukladanie...",
     "saveSettings": "Uložiť nastavenia",
     "previous": "Predchádzajúca",
-    "next": "Ďalšia"
+    "next": "Ďalšia",
+    "invalidJson": "Neplatný JSON — očakáva sa objekt textových hodnôt",
+    "fieldRequired": "{{field}} je povinné"
   },
   "pagination": {
     "previous": "Predchádzajúca",
diff --git a/packages/i18n/src/locales/sk/rules.json b/packages/i18n/src/locales/sk/rules.json
index 10536f1c..f859c9df 100644
--- a/packages/i18n/src/locales/sk/rules.json
+++ b/packages/i18n/src/locales/sk/rules.json
@@ -146,7 +146,18 @@
     "include": "Zahrnúť (biela listina)",
     "exclude": "Vylúčiť (čierna listina)",
     "clearAll": "Vymazať všetky podmienky",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "Odstrániť {{label}}",
+    "collapse": "Zbaliť podmienky",
+    "userIdInvalid": "Zadajte platné ID používateľa Discord (17 – 20 číslic)",
+    "addUserId": "Pridať ID používateľa",
+    "includeChannels": "Len v týchto kanáloch",
+    "includeRoles": "Len členovia s týmito rolami",
+    "includeUsers": "Len títo členovia",
+    "excludeChannels": "Nikdy v týchto kanáloch",
+    "excludeRoles": "Nikdy členovia s týmito rolami",
+    "excludeUsers": "Nikdy títo členovia",
+    "unsupportedWarning": "Tento spúšťač nedokáže vyhodnotiť tieto filtre ({{filters}}), takže pravidlo sa nikdy nespustí, kým sú nastavené.",
+    "removeUnsupported": "Odstrániť filtre, ktoré nemožno použiť"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "Zahodiť neuložené zmeny?",
+    "discardChangesDescription": "Toto pravidlo obsahuje neuložené zmeny. Zatvorením editora o ne prídete.",
+    "discardChanges": "Zahodiť zmeny",
+    "draftRestored": "Koncept obnovený z predchádzajúcej relácie",
+    "discardDraftAction": "Zahodiť koncept",
+    "discardTitle": "Zahodiť zmeny?",
+    "discardDescription": "Máte neuložené zmeny. Koncept sa ukladá lokálne, ale opustíte editor.",
+    "discardConfirm": "Zahodiť a zavrieť"
   },
   "panel": {
     "trigger": "Trigger Settings",
diff --git a/packages/i18n/src/locales/sl/common.json b/packages/i18n/src/locales/sl/common.json
index 9fbdf527..5d7171b9 100644
--- a/packages/i18n/src/locales/sl/common.json
+++ b/packages/i18n/src/locales/sl/common.json
@@ -90,7 +90,9 @@
     "saving": "Shranjevanje...",
     "saveSettings": "Shrani nastavitve",
     "previous": "Prejšnje",
-    "next": "Naslednje"
+    "next": "Naslednje",
+    "invalidJson": "Neveljaven JSON — pričakovan je objekt besedilnih vrednosti",
+    "fieldRequired": "{{field}} je obvezno"
   },
   "pagination": {
     "previous": "Prejšnje",
diff --git a/packages/i18n/src/locales/sl/rules.json b/packages/i18n/src/locales/sl/rules.json
index 20a9d08d..78778166 100644
--- a/packages/i18n/src/locales/sl/rules.json
+++ b/packages/i18n/src/locales/sl/rules.json
@@ -146,7 +146,18 @@
     "include": "Vključi (beli seznam)",
     "exclude": "Izključi (črni seznam)",
     "clearAll": "Počisti vse pogoje",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "Odstrani {{label}}",
+    "collapse": "Strni pogoje",
+    "userIdInvalid": "Vnesite veljaven Discord ID uporabnika (17–20 števk)",
+    "addUserId": "Dodaj ID uporabnika",
+    "includeChannels": "Samo v teh kanalih",
+    "includeRoles": "Samo člani s temi vlogami",
+    "includeUsers": "Samo ti člani",
+    "excludeChannels": "Nikoli v teh kanalih",
+    "excludeRoles": "Nikoli člani s temi vlogami",
+    "excludeUsers": "Nikoli ti člani",
+    "unsupportedWarning": "Ta sprožilec ne more oceniti teh filtrov ({{filters}}), zato se pravilo nikoli ne bo izvedlo, dokler so nastavljeni.",
+    "removeUnsupported": "Odstrani filtre, ki jih ni mogoče uporabiti"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "Zavržem neshranjene spremembe?",
+    "discardChangesDescription": "To pravilo ima neshranjene spremembe. Če zaprete urejevalnik, bodo izgubljene.",
+    "discardChanges": "Zavrzi spremembe",
+    "draftRestored": "Osnutek obnovljen iz prejšnje seje",
+    "discardDraftAction": "Zavrzi osnutek",
+    "discardTitle": "Zavržem spremembe?",
+    "discardDescription": "Imate neshranjene spremembe. Osnutek se shrani lokalno, vendar boste zapustili urejevalnik.",
+    "discardConfirm": "Zavrzi in zapri"
   },
   "panel": {
     "trigger": "Trigger Settings",
diff --git a/packages/i18n/src/locales/sr/common.json b/packages/i18n/src/locales/sr/common.json
index 8741c1a2..f9b3ae75 100644
--- a/packages/i18n/src/locales/sr/common.json
+++ b/packages/i18n/src/locales/sr/common.json
@@ -90,7 +90,9 @@
     "saving": "Чување...",
     "saveSettings": "Сачувај подешавања",
     "previous": "Претходна",
-    "next": "Следећа"
+    "next": "Следећа",
+    "invalidJson": "Неважећи JSON — очекује се објекат текстуалних вредности",
+    "fieldRequired": "{{field}} је обавезно"
   },
   "pagination": {
     "previous": "Претходна",
diff --git a/packages/i18n/src/locales/sr/rules.json b/packages/i18n/src/locales/sr/rules.json
index 0ce4b8c2..fe3a7e56 100644
--- a/packages/i18n/src/locales/sr/rules.json
+++ b/packages/i18n/src/locales/sr/rules.json
@@ -146,7 +146,18 @@
     "include": "Укључи (бела листа)",
     "exclude": "Искључи (црна листа)",
     "clearAll": "Обриши све услове",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "Уклони {{label}}",
+    "collapse": "Скупи услове",
+    "userIdInvalid": "Унесите важећи Discord кориснички ИД (17–20 цифара)",
+    "addUserId": "Додај кориснички ИД",
+    "includeChannels": "Само у овим каналима",
+    "includeRoles": "Само чланови са овим улогама",
+    "includeUsers": "Само ови чланови",
+    "excludeChannels": "Никада у овим каналима",
+    "excludeRoles": "Никада чланови са овим улогама",
+    "excludeUsers": "Никада ови чланови",
+    "unsupportedWarning": "Овај окидач не може да процени ове филтере ({{filters}}), па се правило никада неће покренути док су подешени.",
+    "removeUnsupported": "Уклони филтере који се не могу применити"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "Одбацити несачуване измене?",
+    "discardChangesDescription": "Ово правило има измене које нису сачуване. Затварањем уређивача биће изгубљене.",
+    "discardChanges": "Одбаци измене",
+    "draftRestored": "Нацрт враћен из претходне сесије",
+    "discardDraftAction": "Одбаци нацрт",
+    "discardTitle": "Одбацити измене?",
+    "discardDescription": "Имате несачуване измене. Нацрт се чува локално, али ћете напустити уређивач.",
+    "discardConfirm": "Одбаци и затвори"
   },
   "panel": {
     "trigger": "Trigger Settings",
diff --git a/packages/i18n/src/locales/sv/common.json b/packages/i18n/src/locales/sv/common.json
index 23b1cded..3ca0a1a9 100644
--- a/packages/i18n/src/locales/sv/common.json
+++ b/packages/i18n/src/locales/sv/common.json
@@ -90,7 +90,9 @@
     "saving": "Sparar...",
     "saveSettings": "Spara inställningar",
     "previous": "Föregående",
-    "next": "Nästa"
+    "next": "Nästa",
+    "invalidJson": "Ogiltig JSON — ett objekt med textvärden förväntas",
+    "fieldRequired": "{{field}} är obligatoriskt"
   },
   "pagination": {
     "previous": "Föregående",
diff --git a/packages/i18n/src/locales/sv/rules.json b/packages/i18n/src/locales/sv/rules.json
index 635ebc3b..b1e63b78 100644
--- a/packages/i18n/src/locales/sv/rules.json
+++ b/packages/i18n/src/locales/sv/rules.json
@@ -146,7 +146,18 @@
     "include": "Inkludera (vitlista)",
     "exclude": "Exkludera (svartlista)",
     "clearAll": "Rensa alla villkor",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "Ta bort {{label}}",
+    "collapse": "Dölj villkor",
+    "userIdInvalid": "Ange ett giltigt Discord-användar-ID (17–20 siffror)",
+    "addUserId": "Lägg till användar-ID",
+    "includeChannels": "Endast i dessa kanaler",
+    "includeRoles": "Endast medlemmar med dessa roller",
+    "includeUsers": "Endast dessa medlemmar",
+    "excludeChannels": "Aldrig i dessa kanaler",
+    "excludeRoles": "Aldrig medlemmar med dessa roller",
+    "excludeUsers": "Aldrig dessa medlemmar",
+    "unsupportedWarning": "Den här utlösaren kan inte utvärdera dessa filter ({{filters}}), så regeln körs aldrig så länge de är angivna.",
+    "removeUnsupported": "Ta bort filter som inte kan tillämpas"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "Kasta ogesparade ändringar?",
+    "discardChangesDescription": "Den här regeln har ändringar som inte sparats. Om du stänger redigeraren går de förlorade.",
+    "discardChanges": "Kasta ändringar",
+    "draftRestored": "Utkast återställt från en tidigare session",
+    "discardDraftAction": "Kasta utkast",
+    "discardTitle": "Kasta ändringar?",
+    "discardDescription": "Du har osparade ändringar. Ditt utkast sparas lokalt, men du lämnar redigeraren.",
+    "discardConfirm": "Kasta och stäng"
   },
   "panel": {
     "trigger": "Trigger Settings",
diff --git a/packages/i18n/src/locales/sw/common.json b/packages/i18n/src/locales/sw/common.json
index b2ece8ed..40606999 100644
--- a/packages/i18n/src/locales/sw/common.json
+++ b/packages/i18n/src/locales/sw/common.json
@@ -90,7 +90,9 @@
     "saving": "Inahifadhi...",
     "saveSettings": "Hifadhi Mipangilio",
     "previous": "Iliyotangulia",
-    "next": "Inayofuata"
+    "next": "Inayofuata",
+    "invalidJson": "Si JSON halali — kitu chenye thamani za maandishi kinatarajiwa",
+    "fieldRequired": "{{field}} inahitajika"
   },
   "pagination": {
     "previous": "Iliyotangulia",
diff --git a/packages/i18n/src/locales/sw/rules.json b/packages/i18n/src/locales/sw/rules.json
index e41532a6..d4e3304b 100644
--- a/packages/i18n/src/locales/sw/rules.json
+++ b/packages/i18n/src/locales/sw/rules.json
@@ -146,7 +146,18 @@
     "include": "Jumuisha (orodha nyeupe)",
     "exclude": "Tenga (orodha nyeusi)",
     "clearAll": "Futa masharti yote",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "Ondoa {{label}}",
+    "collapse": "Kunja masharti",
+    "userIdInvalid": "Weka kitambulisho halali cha mtumiaji wa Discord (tarakimu 17–20)",
+    "addUserId": "Ongeza kitambulisho cha mtumiaji",
+    "includeChannels": "Katika chaneli hizi pekee",
+    "includeRoles": "Wanachama wenye majukumu haya pekee",
+    "includeUsers": "Wanachama hawa pekee",
+    "excludeChannels": "Kamwe katika chaneli hizi",
+    "excludeRoles": "Kamwe wanachama wenye majukumu haya",
+    "excludeUsers": "Kamwe wanachama hawa",
+    "unsupportedWarning": "Kianzishi hiki hakiwezi kutathmini vichujio hivi ({{filters}}), kwa hivyo sheria haitatekelezwa kamwe vikiwa vimewekwa.",
+    "removeUnsupported": "Ondoa vichujio visivyoweza kutumika"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "Tupa mabadiliko ambayo hayajahifadhiwa?",
+    "discardChangesDescription": "Sheria hii ina mabadiliko ambayo hayajahifadhiwa. Kufunga kihariri kutayapoteza.",
+    "discardChanges": "Tupa mabadiliko",
+    "draftRestored": "Rasimu imerejeshwa kutoka kipindi kilichopita",
+    "discardDraftAction": "Tupa rasimu",
+    "discardTitle": "Tupa mabadiliko?",
+    "discardDescription": "Una mabadiliko ambayo hayajahifadhiwa. Rasimu yako imehifadhiwa ndani, lakini utaondoka kwenye kihariri.",
+    "discardConfirm": "Tupa na ufunge"
   },
   "panel": {
     "trigger": "Trigger Settings",
diff --git a/packages/i18n/src/locales/ta/common.json b/packages/i18n/src/locales/ta/common.json
index d5fd862c..0899906c 100644
--- a/packages/i18n/src/locales/ta/common.json
+++ b/packages/i18n/src/locales/ta/common.json
@@ -90,7 +90,9 @@
     "saving": "சேமிக்கிறது...",
     "saveSettings": "அமைப்புகளை சேமி",
     "previous": "முந்தைய",
-    "next": "அடுத்து"
+    "next": "அடுத்து",
+    "invalidJson": "சரியான JSON அல்ல — உரை மதிப்புகளின் ஒரு பொருள் எதிர்பார்க்கப்படுகிறது",
+    "fieldRequired": "{{field}} தேவை"
   },
   "pagination": {
     "previous": "முந்தைய",
diff --git a/packages/i18n/src/locales/ta/rules.json b/packages/i18n/src/locales/ta/rules.json
index fa5db6d9..788e04dc 100644
--- a/packages/i18n/src/locales/ta/rules.json
+++ b/packages/i18n/src/locales/ta/rules.json
@@ -146,7 +146,18 @@
     "include": "சேர்க்கை (வெள்ளைப் பட்டியல்)",
     "exclude": "விலக்கு (கறுப்பு பட்டியல்)",
     "clearAll": "அனைத்து நிபந்தனைகளையும் அழி",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "{{label}} அகற்று",
+    "collapse": "நிபந்தனைகளைச் சுருக்கு",
+    "userIdInvalid": "சரியான Discord பயனர் ஐடியை உள்ளிடவும் (17–20 இலக்கங்கள்)",
+    "addUserId": "பயனர் ஐடியைச் சேர்",
+    "includeChannels": "இந்தச் சேனல்களில் மட்டும்",
+    "includeRoles": "இந்தப் பாத்திரங்களைக் கொண்ட உறுப்பினர்கள் மட்டும்",
+    "includeUsers": "இந்த உறுப்பினர்கள் மட்டும்",
+    "excludeChannels": "இந்தச் சேனல்களில் ஒருபோதும் இல்லை",
+    "excludeRoles": "இந்தப் பாத்திரங்களைக் கொண்ட உறுப்பினர்கள் ஒருபோதும் இல்லை",
+    "excludeUsers": "இந்த உறுப்பினர்கள் ஒருபோதும் இல்லை",
+    "unsupportedWarning": "இந்தத் தூண்டுதலால் இந்த வடிப்பான்களை ({{filters}}) மதிப்பிட முடியாது, எனவே அவை அமைக்கப்பட்டிருக்கும் வரை விதி ஒருபோதும் இயங்காது.",
+    "removeUnsupported": "பொருந்தாத வடிப்பான்களை அகற்று"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "சேமிக்கப்படாத மாற்றங்களை நிராகரிக்கவா?",
+    "discardChangesDescription": "இந்த விதியில் சேமிக்கப்படாத மாற்றங்கள் உள்ளன. திருத்தியை மூடினால் அவை இழக்கப்படும்.",
+    "discardChanges": "மாற்றங்களை நிராகரி",
+    "draftRestored": "முந்தைய அமர்விலிருந்து வரைவு மீட்டெடுக்கப்பட்டது",
+    "discardDraftAction": "வரைவை நிராகரி",
+    "discardTitle": "மாற்றங்களை நிராகரிக்கவா?",
+    "discardDescription": "சேமிக்கப்படாத மாற்றங்கள் உள்ளன. வரைவு அக்கணினியில் சேமிக்கப்படும், ஆனால் திருத்தியை விட்டு வெளியேறுவீர்கள்.",
+    "discardConfirm": "நிராகரித்து மூடு"
   },
   "panel": {
     "trigger": "Trigger Settings",
diff --git a/packages/i18n/src/locales/th/common.json b/packages/i18n/src/locales/th/common.json
index c7536290..2d0217d4 100644
--- a/packages/i18n/src/locales/th/common.json
+++ b/packages/i18n/src/locales/th/common.json
@@ -90,7 +90,9 @@
     "saving": "กำลังบันทึก...",
     "saveSettings": "บันทึกการตั้งค่า",
     "previous": "ก่อนหน้า",
-    "next": "ถัดไป"
+    "next": "ถัดไป",
+    "invalidJson": "JSON ไม่ถูกต้อง — ต้องเป็นออบเจ็กต์ของค่าข้อความ",
+    "fieldRequired": "ต้องระบุ {{field}}"
   },
   "pagination": {
     "previous": "ก่อนหน้า",
diff --git a/packages/i18n/src/locales/th/rules.json b/packages/i18n/src/locales/th/rules.json
index 111270de..1a86c5a6 100644
--- a/packages/i18n/src/locales/th/rules.json
+++ b/packages/i18n/src/locales/th/rules.json
@@ -146,7 +146,18 @@
     "include": "รวม (ไวท์ลิสต์)",
     "exclude": "ยกเว้น (แบล็กลิสต์)",
     "clearAll": "ล้างเงื่อนไขทั้งหมด",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "ลบ {{label}}",
+    "collapse": "ยุบเงื่อนไข",
+    "userIdInvalid": "ป้อนรหัสผู้ใช้ Discord ที่ถูกต้อง (17–20 หลัก)",
+    "addUserId": "เพิ่มรหัสผู้ใช้",
+    "includeChannels": "เฉพาะในช่องเหล่านี้",
+    "includeRoles": "เฉพาะสมาชิกที่มีบทบาทเหล่านี้",
+    "includeUsers": "เฉพาะสมาชิกเหล่านี้",
+    "excludeChannels": "ไม่เคยในช่องเหล่านี้",
+    "excludeRoles": "ไม่เคยสมาชิกที่มีบทบาทเหล่านี้",
+    "excludeUsers": "ไม่เคยสมาชิกเหล่านี้",
+    "unsupportedWarning": "ทริกเกอร์นี้ไม่สามารถประเมินตัวกรองเหล่านี้ ({{filters}}) ได้ กฎจึงจะไม่ทำงานตราบใดที่ยังตั้งค่าไว้",
+    "removeUnsupported": "ลบตัวกรองที่ใช้ไม่ได้"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "ละทิ้งการเปลี่ยนแปลงที่ยังไม่ได้บันทึกหรือไม่",
+    "discardChangesDescription": "กฎนี้มีการเปลี่ยนแปลงที่ยังไม่ได้บันทึก การปิดตัวแก้ไขจะทำให้สูญหาย",
+    "discardChanges": "ละทิ้งการเปลี่ยนแปลง",
+    "draftRestored": "กู้คืนฉบับร่างจากเซสชันก่อนหน้าแล้ว",
+    "discardDraftAction": "ละทิ้งฉบับร่าง",
+    "discardTitle": "ละทิ้งการเปลี่ยนแปลงหรือไม่",
+    "discardDescription": "คุณมีการเปลี่ยนแปลงที่ยังไม่ได้บันทึก ฉบับร่างถูกบันทึกไว้ในเครื่อง แต่คุณจะออกจากตัวแก้ไข",
+    "discardConfirm": "ละทิ้งและปิด"
   },
   "panel": {
     "trigger": "Trigger Settings",
diff --git a/packages/i18n/src/locales/tr/common.json b/packages/i18n/src/locales/tr/common.json
index 6feedd6f..6f780386 100644
--- a/packages/i18n/src/locales/tr/common.json
+++ b/packages/i18n/src/locales/tr/common.json
@@ -90,7 +90,9 @@
     "saving": "Kaydediliyor...",
     "saveSettings": "Ayarları Kaydet",
     "previous": "Önceki",
-    "next": "İleri"
+    "next": "İleri",
+    "invalidJson": "Geçerli JSON değil — metin değerlerinden oluşan bir nesne bekleniyor",
+    "fieldRequired": "{{field}} gerekli"
   },
   "pagination": {
     "previous": "Önceki",
diff --git a/packages/i18n/src/locales/tr/rules.json b/packages/i18n/src/locales/tr/rules.json
index 67ec30d0..6ee1eb97 100644
--- a/packages/i18n/src/locales/tr/rules.json
+++ b/packages/i18n/src/locales/tr/rules.json
@@ -146,7 +146,18 @@
     "include": "Dahil Et (beyaz liste)",
     "exclude": "Hariç Tut (kara liste)",
     "clearAll": "Tüm koşulları temizle",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "{{label}} öğesini kaldır",
+    "collapse": "Koşulları daralt",
+    "userIdInvalid": "Geçerli bir Discord kullanıcı kimliği girin (17–20 hane)",
+    "addUserId": "Kullanıcı kimliği ekle",
+    "includeChannels": "Yalnızca bu kanallarda",
+    "includeRoles": "Yalnızca bu rollere sahip üyeler",
+    "includeUsers": "Yalnızca bu üyeler",
+    "excludeChannels": "Bu kanallarda asla",
+    "excludeRoles": "Bu rollere sahip üyelerde asla",
+    "excludeUsers": "Bu üyelerde asla",
+    "unsupportedWarning": "Bu tetikleyici bu filtreleri ({{filters}}) değerlendiremez, bu nedenle filtreler ayarlı olduğu sürece kural asla çalışmaz.",
+    "removeUnsupported": "Uygulanamayan filtreleri kaldır"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "Kaydedilmemiş değişiklikler atılsın mı?",
+    "discardChangesDescription": "Bu kuralda kaydedilmemiş değişiklikler var. Düzenleyiciyi kapatmak bunları kaybeder.",
+    "discardChanges": "Değişiklikleri at",
+    "draftRestored": "Taslak önceki oturumdan geri yüklendi",
+    "discardDraftAction": "Taslağı at",
+    "discardTitle": "Değişiklikler atılsın mı?",
+    "discardDescription": "Kaydedilmemiş değişiklikleriniz var. Taslağınız yerel olarak saklanır, ancak düzenleyiciden çıkacaksınız.",
+    "discardConfirm": "At ve kapat"
   },
   "panel": {
     "trigger": "Trigger Settings",
diff --git a/packages/i18n/src/locales/uk/common.json b/packages/i18n/src/locales/uk/common.json
index ffd931da..89450cc0 100644
--- a/packages/i18n/src/locales/uk/common.json
+++ b/packages/i18n/src/locales/uk/common.json
@@ -90,7 +90,9 @@
     "saving": "Збереження...",
     "saveSettings": "Зберегти налаштування",
     "previous": "Назад",
-    "next": "Далі"
+    "next": "Далі",
+    "invalidJson": "Некоректний JSON — очікується об'єкт текстових значень",
+    "fieldRequired": "Поле «{{field}}» обов'язкове"
   },
   "pagination": {
     "previous": "Назад",
diff --git a/packages/i18n/src/locales/uk/rules.json b/packages/i18n/src/locales/uk/rules.json
index e2f94229..a1bd6642 100644
--- a/packages/i18n/src/locales/uk/rules.json
+++ b/packages/i18n/src/locales/uk/rules.json
@@ -146,7 +146,18 @@
     "include": "Включити (білий список)",
     "exclude": "Виключити (чорний список)",
     "clearAll": "Очистити всі умови",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "Видалити {{label}}",
+    "collapse": "Згорнути умови",
+    "userIdInvalid": "Введіть дійсний ідентифікатор користувача Discord (17–20 цифр)",
+    "addUserId": "Додати ідентифікатор користувача",
+    "includeChannels": "Лише в цих каналах",
+    "includeRoles": "Лише учасники з цими ролями",
+    "includeUsers": "Лише ці учасники",
+    "excludeChannels": "Ніколи в цих каналах",
+    "excludeRoles": "Ніколи учасники з цими ролями",
+    "excludeUsers": "Ніколи ці учасники",
+    "unsupportedWarning": "Цей тригер не може обчислити ці фільтри ({{filters}}), тому правило ніколи не спрацює, доки їх задано.",
+    "removeUnsupported": "Видалити фільтри, які неможливо застосувати"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "Скасувати незбережені зміни?",
+    "discardChangesDescription": "У цьому правилі є незбережені зміни. Закриття редактора призведе до їх втрати.",
+    "discardChanges": "Скасувати зміни",
+    "draftRestored": "Чернетку відновлено з попереднього сеансу",
+    "discardDraftAction": "Скасувати чернетку",
+    "discardTitle": "Скасувати зміни?",
+    "discardDescription": "Є незбережені зміни. Чернетка зберігається локально, але ви залишите редактор.",
+    "discardConfirm": "Скасувати й закрити"
   },
   "panel": {
     "trigger": "Trigger Settings",
diff --git a/packages/i18n/src/locales/ur/common.json b/packages/i18n/src/locales/ur/common.json
index a139d7de..95ef3c0c 100644
--- a/packages/i18n/src/locales/ur/common.json
+++ b/packages/i18n/src/locales/ur/common.json
@@ -90,7 +90,9 @@
     "saving": "محفوظ ہو رہا ہے...",
     "saveSettings": "ترتیبات محفوظ کریں",
     "previous": "پچھلا",
-    "next": "اگلا"
+    "next": "اگلا",
+    "invalidJson": "درست JSON نہیں — متنی اقدار پر مشتمل آبجیکٹ متوقع ہے",
+    "fieldRequired": "{{field}} درکار ہے"
   },
   "pagination": {
     "previous": "پچھلا",
diff --git a/packages/i18n/src/locales/ur/rules.json b/packages/i18n/src/locales/ur/rules.json
index 59f5f621..26675a2e 100644
--- a/packages/i18n/src/locales/ur/rules.json
+++ b/packages/i18n/src/locales/ur/rules.json
@@ -146,7 +146,18 @@
     "include": "شامل کریں (سفید فہرست)",
     "exclude": "خارج کریں (کالی فہرست)",
     "clearAll": "تمام شرائط صاف کریں",
-    "removeItem": "{{label}} ہٹائیں"
+    "removeItem": "{{label}} ہٹائیں",
+    "collapse": "شرائط سمیٹیں",
+    "userIdInvalid": "درست Discord صارف شناخت درج کریں (17–20 ہندسے)",
+    "addUserId": "صارف شناخت شامل کریں",
+    "includeChannels": "صرف ان چینلز میں",
+    "includeRoles": "صرف ان کرداروں والے اراکین",
+    "includeUsers": "صرف یہ اراکین",
+    "excludeChannels": "ان چینلز میں کبھی نہیں",
+    "excludeRoles": "ان کرداروں والے اراکین کبھی نہیں",
+    "excludeUsers": "یہ اراکین کبھی نہیں",
+    "unsupportedWarning": "یہ ٹریگر ان فلٹرز ({{filters}}) کا جائزہ نہیں لے سکتا، اس لیے جب تک یہ مقرر ہیں قاعدہ کبھی نہیں چلے گا۔",
+    "removeUnsupported": "وہ فلٹرز ہٹائیں جو لاگو نہیں ہو سکتے"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "نظارے کے مطابق کریں"
     },
     "issues_one": "{{count}} مسئلہ",
-    "issues_other": "{{count}} مسائل"
+    "issues_other": "{{count}} مسائل",
+    "discardChangesTitle": "غیر محفوظ تبدیلیاں رد کریں؟",
+    "discardChangesDescription": "اس قاعدے میں ایسی تبدیلیاں ہیں جو محفوظ نہیں ہوئیں۔ ایڈیٹر بند کرنے پر وہ ضائع ہو جائیں گی۔",
+    "discardChanges": "تبدیلیاں رد کریں",
+    "draftRestored": "پچھلے سیشن سے مسودہ بحال کر دیا گیا",
+    "discardDraftAction": "مسودہ رد کریں",
+    "discardTitle": "تبدیلیاں رد کریں؟",
+    "discardDescription": "آپ کے پاس غیر محفوظ تبدیلیاں ہیں۔ مسودہ مقامی طور پر محفوظ ہے، لیکن آپ ایڈیٹر سے نکل جائیں گے۔",
+    "discardConfirm": "رد کریں اور بند کریں"
   },
   "panel": {
     "trigger": "ٹرگر ترتیبات",
diff --git a/packages/i18n/src/locales/vi/common.json b/packages/i18n/src/locales/vi/common.json
index 725f288b..db730b7b 100644
--- a/packages/i18n/src/locales/vi/common.json
+++ b/packages/i18n/src/locales/vi/common.json
@@ -90,7 +90,9 @@
     "saving": "Đang lưu...",
     "saveSettings": "Lưu Cài Đặt",
     "previous": "Trước",
-    "next": "Tiếp"
+    "next": "Tiếp",
+    "invalidJson": "JSON không hợp lệ — cần một đối tượng gồm các giá trị văn bản",
+    "fieldRequired": "{{field}} là bắt buộc"
   },
   "pagination": {
     "previous": "Trước",
diff --git a/packages/i18n/src/locales/vi/rules.json b/packages/i18n/src/locales/vi/rules.json
index 949e58c8..84a70251 100644
--- a/packages/i18n/src/locales/vi/rules.json
+++ b/packages/i18n/src/locales/vi/rules.json
@@ -146,7 +146,18 @@
     "include": "Bao Gồm (danh sách trắng)",
     "exclude": "Loại Trừ (danh sách đen)",
     "clearAll": "Xóa tất cả điều kiện",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "Xóa {{label}}",
+    "collapse": "Thu gọn điều kiện",
+    "userIdInvalid": "Nhập ID người dùng Discord hợp lệ (17–20 chữ số)",
+    "addUserId": "Thêm ID người dùng",
+    "includeChannels": "Chỉ trong các kênh này",
+    "includeRoles": "Chỉ thành viên có các vai trò này",
+    "includeUsers": "Chỉ những thành viên này",
+    "excludeChannels": "Không bao giờ trong các kênh này",
+    "excludeRoles": "Không bao giờ thành viên có các vai trò này",
+    "excludeUsers": "Không bao giờ những thành viên này",
+    "unsupportedWarning": "Trình kích hoạt này không thể đánh giá các bộ lọc này ({{filters}}), nên quy tắc sẽ không bao giờ chạy khi chúng còn được đặt.",
+    "removeUnsupported": "Xóa các bộ lọc không thể áp dụng"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "Bỏ các thay đổi chưa lưu?",
+    "discardChangesDescription": "Quy tắc này có các thay đổi chưa được lưu. Đóng trình chỉnh sửa sẽ làm mất chúng.",
+    "discardChanges": "Bỏ thay đổi",
+    "draftRestored": "Đã khôi phục bản nháp từ phiên trước",
+    "discardDraftAction": "Bỏ bản nháp",
+    "discardTitle": "Bỏ các thay đổi?",
+    "discardDescription": "Bạn có thay đổi chưa lưu. Bản nháp được lưu cục bộ, nhưng bạn sẽ rời trình chỉnh sửa.",
+    "discardConfirm": "Bỏ và đóng"
   },
   "panel": {
     "trigger": "Trigger Settings",
diff --git a/packages/i18n/src/locales/zh-CN/common.json b/packages/i18n/src/locales/zh-CN/common.json
index b9b55baa..cc9e3c00 100644
--- a/packages/i18n/src/locales/zh-CN/common.json
+++ b/packages/i18n/src/locales/zh-CN/common.json
@@ -90,7 +90,9 @@
     "saving": "保存中...",
     "saveSettings": "保存设置",
     "previous": "上一步",
-    "next": "下一步"
+    "next": "下一步",
+    "invalidJson": "不是有效的 JSON —— 需要一个文本值对象",
+    "fieldRequired": "{{field}} 为必填项"
   },
   "pagination": {
     "previous": "上一页",
diff --git a/packages/i18n/src/locales/zh-CN/rules.json b/packages/i18n/src/locales/zh-CN/rules.json
index 01af703f..0123f2b9 100644
--- a/packages/i18n/src/locales/zh-CN/rules.json
+++ b/packages/i18n/src/locales/zh-CN/rules.json
@@ -146,7 +146,18 @@
     "include": "包含（白名单）",
     "exclude": "排除（黑名单）",
     "clearAll": "清除所有条件",
-    "removeItem": "移除 {{label}}"
+    "removeItem": "移除 {{label}}",
+    "collapse": "收起条件",
+    "userIdInvalid": "请输入有效的 Discord 用户 ID（17–20 位数字）",
+    "addUserId": "添加用户 ID",
+    "includeChannels": "仅在这些频道",
+    "includeRoles": "仅拥有这些身份组的成员",
+    "includeUsers": "仅这些成员",
+    "excludeChannels": "从不在这些频道",
+    "excludeRoles": "从不对拥有这些身份组的成员",
+    "excludeUsers": "从不对这些成员",
+    "unsupportedWarning": "此触发器无法评估这些筛选条件（{{filters}}），因此只要它们处于设置状态，规则将永远不会触发。",
+    "removeUnsupported": "移除无法生效的筛选条件"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "适应视图"
     },
     "issues_one": "{{count}} 个问题",
-    "issues_other": "{{count}} 个问题"
+    "issues_other": "{{count}} 个问题",
+    "discardChangesTitle": "放弃未保存的更改？",
+    "discardChangesDescription": "此规则有尚未保存的更改。关闭编辑器将会丢失它们。",
+    "discardChanges": "放弃更改",
+    "draftRestored": "已从上一次会话恢复草稿",
+    "discardDraftAction": "放弃草稿",
+    "discardTitle": "放弃更改？",
+    "discardDescription": "你有未保存的更改。草稿会保存在本地，但你将离开编辑器。",
+    "discardConfirm": "放弃并关闭"
   },
   "panel": {
     "trigger": "触发器设置",
diff --git a/packages/i18n/src/locales/zh-TW/common.json b/packages/i18n/src/locales/zh-TW/common.json
index 985c3596..52d8283e 100644
--- a/packages/i18n/src/locales/zh-TW/common.json
+++ b/packages/i18n/src/locales/zh-TW/common.json
@@ -90,7 +90,9 @@
     "saving": "儲存中...",
     "saveSettings": "儲存設定",
     "previous": "上一步",
-    "next": "下一步"
+    "next": "下一步",
+    "invalidJson": "不是有效的 JSON —— 需要一個文字值物件",
+    "fieldRequired": "{{field}} 為必填項"
   },
   "pagination": {
     "previous": "上一頁",
diff --git a/packages/i18n/src/locales/zh-TW/rules.json b/packages/i18n/src/locales/zh-TW/rules.json
index 08381df6..7fc7da91 100644
--- a/packages/i18n/src/locales/zh-TW/rules.json
+++ b/packages/i18n/src/locales/zh-TW/rules.json
@@ -146,7 +146,18 @@
     "include": "包含（白名單）",
     "exclude": "排除（黑名單）",
     "clearAll": "清除所有條件",
-    "removeItem": "Remove {{label}}"
+    "removeItem": "移除 {{label}}",
+    "collapse": "收合條件",
+    "userIdInvalid": "請輸入有效的 Discord 使用者 ID（17–20 位數字）",
+    "addUserId": "新增使用者 ID",
+    "includeChannels": "僅在這些頻道",
+    "includeRoles": "僅擁有這些身分組的成員",
+    "includeUsers": "僅這些成員",
+    "excludeChannels": "從不在這些頻道",
+    "excludeRoles": "從不對擁有這些身分組的成員",
+    "excludeUsers": "從不對這些成員",
+    "unsupportedWarning": "此觸發器無法評估這些篩選條件（{{filters}}），因此只要它們處於設定狀態，規則將永遠不會觸發。",
+    "removeUnsupported": "移除無法生效的篩選條件"
   },
   "workflow": {
     "errors": {
@@ -189,7 +200,15 @@
       "fitView": "Fit view"
     },
     "issues_one": "{{count}} issue",
-    "issues_other": "{{count}} issues"
+    "issues_other": "{{count}} issues",
+    "discardChangesTitle": "放棄未儲存的變更？",
+    "discardChangesDescription": "此規則有尚未儲存的變更。關閉編輯器將會遺失它們。",
+    "discardChanges": "放棄變更",
+    "draftRestored": "已從上一次工作階段還原草稿",
+    "discardDraftAction": "放棄草稿",
+    "discardTitle": "放棄變更？",
+    "discardDescription": "你有未儲存的變更。草稿會儲存在本機，但你將離開編輯器。",
+    "discardConfirm": "放棄並關閉"
   },
   "panel": {
     "trigger": "Trigger Settings",
diff --git a/packages/systems/src/actions/constants.ts b/packages/systems/src/actions/constants.ts
index 642a83d2..8645d843 100644
--- a/packages/systems/src/actions/constants.ts
+++ b/packages/systems/src/actions/constants.ts
@@ -171,7 +171,7 @@ export const TEMPLATE_VARIABLES: Record<string, string> = {
 export interface ActionFieldDescriptor {
   key: string;
   label: string;
-  type: "channel" | "role" | "text" | "textarea" | "color" | "select";
+  type: "channel" | "role" | "text" | "textarea" | "color" | "select" | "json";
   placeholder?: string;
   required?: boolean;
   options?: { value: string; label: string }[];
@@ -206,7 +206,9 @@ export const ACTION_TYPE_FIELDS: Record<ActionType, ActionFieldDescriptor[]> = {
   sendWebhook: [
     { key: "webhook.url", label: "Webhook URL", type: "text", placeholder: "https://...", required: true },
     { key: "webhook.method", label: "HTTP Method", type: "select", options: [{ value: "POST", label: "POST" }, { value: "PUT", label: "PUT" }] },
-    { key: "webhook.headers", label: "Headers (JSON)", type: "textarea", placeholder: '{"Authorization": "Bearer ..."}', maxLength: 1000 },
+    // "json", not "textarea": the model types this as Record<string,string>,
+    // so a raw textarea wrote a string into it and the rule became unsavable.
+    { key: "webhook.headers", label: "Headers (JSON)", type: "json", placeholder: '{"X-Request-Id": "abc"}', maxLength: 1000 },
     { key: "webhook.bodyTemplate", label: "Body Template", type: "textarea", placeholder: "JSON body... supports {user}, {channel}, etc.", maxLength: 2000 },
   ],
   setNickname: [
@@ -221,34 +223,72 @@ export const ACTION_TYPE_FIELDS: Record<ActionType, ActionFieldDescriptor[]> = {
   ],
 };
 
-const GENERAL_VARIABLES = [
-  "{user}", "{user.name}", "{user.tag}", "{user.id}",
-  "{channel}", "{channel.name}", "{channel.id}",
-  "{guild}", "{guild.memberCount}",
-  "{timestamp}",
-];
+/**
+ * Tokens every event context populates: the acting guild and the timestamp.
+ *
+ * Deliberately does NOT include {user*} or {channel*}. Those are only
+ * available on the events whose context actually carries them — see
+ * eventBridge.ts. Promising a token the bot never populates is worse than
+ * omitting it: the dashboard preview renders "#general" while the bot posts
+ * "Unknown Channel", and the editor's unknown-token warning stays silent
+ * because the token looks legitimate.
+ */
+const GUILD_VARIABLES = ["{guild}", "{guild.memberCount}", "{timestamp}"];
+
+/** Populated wherever the event has an acting user. */
+const USER_VARIABLES = ["{user}", "{user.name}", "{user.tag}", "{user.id}"];
+
+/** Populated wherever the event happened in a channel. */
+const CHANNEL_VARIABLES = ["{channel}", "{channel.name}", "{channel.id}"];
+
+const MEMBER_EVENT = [...USER_VARIABLES, ...GUILD_VARIABLES];
+const MESSAGE_EVENT = [...USER_VARIABLES, ...CHANNEL_VARIABLES, ...GUILD_VARIABLES];
 
-/** Maps each event type to its available template variables */
+/**
+ * Maps each event type to the template variables its context ACTUALLY
+ * populates. Pinned against eventBridge.ts by
+ * packages/systems/tests/unit/actions-event-variables.test.ts.
+ */
 export const EVENT_TYPE_VARIABLES: Record<ActionEventType, string[]> = {
-  memberJoin: [...GENERAL_VARIABLES],
-  memberLeave: [...GENERAL_VARIABLES],
-  memberBanned: [...GENERAL_VARIABLES, "{ban.reason}"],
-  memberUnbanned: [...GENERAL_VARIABLES, "{ban.reason}"],
-  messageCreated: [...GENERAL_VARIABLES, "{message.content}", "{message.id}", "{message.url}"],
-  messageDeleted: [...GENERAL_VARIABLES, "{message.content}", "{message.id}", "{message.url}"],
-  reactionAdded: [...GENERAL_VARIABLES, "{emoji}", "{emoji.name}", "{message.id}", "{message.url}"],
-  reactionRemoved: [...GENERAL_VARIABLES, "{emoji}", "{emoji.name}", "{message.id}", "{message.url}"],
-  roleAdded: [...GENERAL_VARIABLES, "{role}", "{role.name}", "{role.id}"],
-  roleRemoved: [...GENERAL_VARIABLES, "{role}", "{role.name}", "{role.id}"],
-  channelCreated: [...GENERAL_VARIABLES],
-  channelDeleted: [...GENERAL_VARIABLES],
-  voiceJoin: [...GENERAL_VARIABLES, "{voice.channel}", "{voice.channel.name}"],
-  voiceLeave: [...GENERAL_VARIABLES, "{voice.channel}", "{voice.channel.name}"],
-  nicknameChanged: [...GENERAL_VARIABLES, "{old.nickname}", "{new.nickname}"],
-  memberTimeout: [...GENERAL_VARIABLES, "{timeout.until}"],
-  threadCreated: [...GENERAL_VARIABLES, "{thread.name}", "{thread.id}"],
-  boostStart: [...GENERAL_VARIABLES, "{boost.since}"],
-  boostEnd: [...GENERAL_VARIABLES],
+  // buildMemberContext — a member, no channel
+  memberJoin: [...MEMBER_EVENT],
+  memberLeave: [...MEMBER_EVENT],
+  nicknameChanged: [...MEMBER_EVENT, "{old.nickname}", "{new.nickname}"],
+  memberTimeout: [...MEMBER_EVENT, "{timeout.until}"],
+  boostStart: [...MEMBER_EVENT, "{boost.since}"],
+  boostEnd: [...MEMBER_EVENT],
+
+  // buildBanContext — a user, no channel
+  memberBanned: [...MEMBER_EVENT, "{ban.reason}"],
+  memberUnbanned: [...MEMBER_EVENT, "{ban.reason}"],
+
+  // buildRoleContext — a member and a role, no channel
+  roleAdded: [...MEMBER_EVENT, "{role}", "{role.name}", "{role.id}"],
+  roleRemoved: [...MEMBER_EVENT, "{role}", "{role.name}", "{role.id}"],
+
+  // buildMessageContext / buildReactionContext — user and channel
+  messageCreated: [...MESSAGE_EVENT, "{message.content}", "{message.id}", "{message.url}"],
+  messageDeleted: [...MESSAGE_EVENT, "{message.content}", "{message.id}", "{message.url}"],
+  reactionAdded: [...MESSAGE_EVENT, "{emoji}", "{emoji.name}", "{message.id}", "{message.url}"],
+  reactionRemoved: [...MESSAGE_EVENT, "{emoji}", "{emoji.name}", "{message.id}", "{message.url}"],
+
+  // buildVoiceContext — user and channel
+  voiceJoin: [...MESSAGE_EVENT, "{voice.channel}", "{voice.channel.name}"],
+  voiceLeave: [...MESSAGE_EVENT, "{voice.channel}", "{voice.channel.name}"],
+
+  // buildChannelContext — a channel, and NO acting user on the gateway event
+  channelCreated: [...CHANNEL_VARIABLES, ...GUILD_VARIABLES],
+  channelDeleted: [...CHANNEL_VARIABLES, ...GUILD_VARIABLES],
+
+  // threadCreate — the owner is a bare id, so no username or tag is resolved
+  threadCreated: [
+    "{user}",
+    "{user.id}",
+    ...CHANNEL_VARIABLES,
+    ...GUILD_VARIABLES,
+    "{thread.name}",
+    "{thread.id}",
+  ],
 };
 
 export const CONDITION_TYPES = [
@@ -262,6 +302,69 @@ export const CONDITION_TYPES = [
 
 export type ConditionType = (typeof CONDITION_TYPES)[number];
 
+/** The three data a trigger filter can key on. */
+export type ConditionSubject = "channel" | "role" | "user";
+
+/**
+ * Which filter subjects each event type can actually be filtered by — i.e.
+ * which of `channelId`, `member` and `userId` the bot populates on that
+ * event's EventContext (see apps/bot/.../eventBridge.ts).
+ *
+ * Trigger filters fail closed: a configured filter the context cannot answer
+ * stops the rule from firing. So offering a filter the trigger can never
+ * satisfy does not merely do nothing — it silently disables the rule. The
+ * dashboard reads this map to only offer filters that can work, and to flag
+ * rules that already carry one that cannot.
+ *
+ * - `channel` — context.channelId is set
+ * - `role`    — context.member is set (role filters read member.roles)
+ * - `user`    — context.userId is set
+ */
+export const EVENT_CONDITION_SUPPORT: Record<ActionEventType, ConditionSubject[]> = {
+  // buildMemberContext — member present unless the gateway sent a partial
+  memberJoin: ["user", "role"],
+  memberLeave: ["user", "role"],
+  nicknameChanged: ["user", "role"],
+  memberTimeout: ["user", "role"],
+  boostStart: ["user", "role"],
+  boostEnd: ["user", "role"],
+
+  // buildBanContext — the user is no longer a member, so there is no member
+  // object to read roles from, on either ban or unban
+  memberBanned: ["user"],
+  memberUnbanned: ["user"],
+
+  // buildMessageContext / buildReactionContext — full context
+  messageCreated: ["user", "role", "channel"],
+  messageDeleted: ["user", "role", "channel"],
+  reactionAdded: ["user", "role", "channel"],
+  reactionRemoved: ["user", "role", "channel"],
+
+  // buildRoleContext — member present, but no channel
+  roleAdded: ["user", "role"],
+  roleRemoved: ["user", "role"],
+
+  // buildChannelContext — no acting user is available on the gateway event
+  channelCreated: ["channel"],
+  channelDeleted: ["channel"],
+
+  // buildVoiceContext — full context
+  voiceJoin: ["user", "role", "channel"],
+  voiceLeave: ["user", "role", "channel"],
+
+  // threadCreate — channelId is the NEW thread, and the owner is a bare id
+  threadCreated: ["user", "channel"],
+};
+
+/** Whether `eventType` can be filtered by `subject`. */
+export function supportsCondition(
+  eventType: string,
+  subject: ConditionSubject,
+): boolean {
+  const supported = EVENT_CONDITION_SUPPORT[eventType as ActionEventType];
+  return supported ? supported.includes(subject) : false;
+}
+
 /**
  * Allowed character set for action rule names. Restricts user-supplied
  * names so they cannot inject markdown, mention syntax, code fences, or
@@ -272,3 +375,28 @@ export const RULE_NAME_REGEX = /^[a-zA-Z0-9 _-]{1,50}$/;
 export function isValidRuleName(name: string): boolean {
   return typeof name === "string" && RULE_NAME_REGEX.test(name);
 }
+
+/**
+ * Characters that must never reach a rule name, because the name is rendered
+ * into Discord embeds, `/actions` autocomplete and audit logs:
+ * markdown/code-fence syntax, mention syntax, and any control, zero-width or
+ * bidirectional-override character (which can hide or reverse the visible
+ * text entirely).
+ */
+const UNSAFE_NAME_CHARS =
+  /[`*_~|\\<>@#\u0000-\u001F\u007F\u200B-\u200F\u202A-\u202E\u2066-\u2069\uFEFF]/u;
+
+/**
+ * The dashboard's rule-name guard.
+ *
+ * Deliberately NOT `isValidRuleName`: that one is ASCII-only, and the preset
+ * rule templates produce non-ASCII names in 47 of the 48 locales, so applying
+ * it to the API would reject the product's own onboarding path. This keeps the
+ * same injection protection while allowing any script.
+ */
+export function isSafeRuleName(name: string): boolean {
+  if (typeof name !== "string") return false;
+  const trimmed = name.trim();
+  if (trimmed.length < 1 || trimmed.length > 50) return false;
+  return !UNSAFE_NAME_CHARS.test(trimmed);
+}
diff --git a/packages/systems/src/actions/types.ts b/packages/systems/src/actions/types.ts
index 202448dc..50dd471b 100644
--- a/packages/systems/src/actions/types.ts
+++ b/packages/systems/src/actions/types.ts
@@ -99,6 +99,14 @@ export interface EventContext {
   channelId?: string;
   channelName?: string;
   channelMention?: string;
+  /**
+   * The parent of `channelId`, when the event's channel is itself nested —
+   * currently only threadCreated, where `channelId` is the brand-new thread.
+   * Channel filters test this too, so "only threads under #support" is
+   * expressible; without it a channel filter on threadCreated could never
+   * match anything the user is able to pick.
+   */
+  parentChannelId?: string;
   roleId?: string;
   roleName?: string;
   roleMention?: string;
diff --git a/packages/systems/tests/unit/actions-condition-support.test.ts b/packages/systems/tests/unit/actions-condition-support.test.ts
new file mode 100644
index 00000000..b802e743
--- /dev/null
+++ b/packages/systems/tests/unit/actions-condition-support.test.ts
@@ -0,0 +1,80 @@
+import { describe, it, expect } from "vitest";
+import {
+  EVENT_TYPES,
+  EVENT_CONDITION_SUPPORT,
+  supportsCondition,
+  type ConditionSubject,
+} from "../../src/actions/constants.js";
+
+const SUBJECTS: ConditionSubject[] = ["channel", "role", "user"];
+
+describe("EVENT_CONDITION_SUPPORT", () => {
+  // Trigger filters fail closed, so a filter offered for an event that cannot
+  // answer it silently disables the rule. A missing entry here would read as
+  // "supports nothing", which is the safe direction — but it would also strip
+  // every filter from that trigger in the editor, so the gap must be loud.
+  it("covers every event type", () => {
+    for (const eventType of Object.keys(EVENT_TYPES)) {
+      expect(
+        EVENT_CONDITION_SUPPORT[eventType as keyof typeof EVENT_CONDITION_SUPPORT],
+      ).toBeDefined();
+    }
+  });
+
+  it("declares no unknown event types", () => {
+    for (const eventType of Object.keys(EVENT_CONDITION_SUPPORT)) {
+      expect(EVENT_TYPES).toHaveProperty(eventType);
+    }
+  });
+
+  it("only lists known subjects, with no duplicates", () => {
+    for (const [eventType, subjects] of Object.entries(EVENT_CONDITION_SUPPORT)) {
+      expect(subjects.length, eventType).toBeGreaterThan(0);
+      expect(new Set(subjects).size, eventType).toBe(subjects.length);
+      for (const subject of subjects) {
+        expect(SUBJECTS, eventType).toContain(subject);
+      }
+    }
+  });
+
+  // These four are the combinations that were silently broken before filters
+  // failed closed — they are the reason this map exists.
+  it("does not offer role filters on ban events (the user is no longer a member)", () => {
+    expect(supportsCondition("memberBanned", "role")).toBe(false);
+    expect(supportsCondition("memberUnbanned", "role")).toBe(false);
+  });
+
+  it("does not offer channel filters on member events (no channel in context)", () => {
+    expect(supportsCondition("memberJoin", "channel")).toBe(false);
+    expect(supportsCondition("memberLeave", "channel")).toBe(false);
+  });
+
+  it("does not offer user filters on channel events (no acting user in context)", () => {
+    expect(supportsCondition("channelCreated", "user")).toBe(false);
+    expect(supportsCondition("channelDeleted", "user")).toBe(false);
+  });
+
+  it("does not offer role filters on threadCreated (the owner is a bare id)", () => {
+    expect(supportsCondition("threadCreated", "role")).toBe(false);
+    expect(supportsCondition("threadCreated", "channel")).toBe(true);
+  });
+
+  it("offers the full set on message, reaction and voice events", () => {
+    for (const eventType of [
+      "messageCreated",
+      "messageDeleted",
+      "reactionAdded",
+      "reactionRemoved",
+      "voiceJoin",
+      "voiceLeave",
+    ]) {
+      for (const subject of SUBJECTS) {
+        expect(supportsCondition(eventType, subject), `${eventType}/${subject}`).toBe(true);
+      }
+    }
+  });
+
+  it("reports false for an unknown event type rather than throwing", () => {
+    expect(supportsCondition("notAnEvent", "user")).toBe(false);
+  });
+});
diff --git a/packages/systems/tests/unit/actions-event-variables.test.ts b/packages/systems/tests/unit/actions-event-variables.test.ts
new file mode 100644
index 00000000..4d039754
--- /dev/null
+++ b/packages/systems/tests/unit/actions-event-variables.test.ts
@@ -0,0 +1,116 @@
+import { describe, it, expect } from "vitest";
+import {
+  EVENT_TYPES,
+  EVENT_TYPE_VARIABLES,
+  TEMPLATE_VARIABLES,
+  EVENT_CONDITION_SUPPORT,
+} from "../../src/actions/constants.js";
+
+/**
+ * EVENT_TYPE_VARIABLES is a promise to the user: these are the tokens you may
+ * write in a template for this trigger. It used to hand every event the same
+ * GENERAL_VARIABLES block, so a memberJoin rule advertised {channel} and a
+ * channelCreated rule advertised {user.name} — neither of which the bot
+ * populates. The dashboard preview rendered "#general" / "@Ada" while the bot
+ * posted "Unknown Channel" / "Unknown", and the editor's unknown-token warning
+ * stayed silent because the token looked legitimate.
+ *
+ * These assertions pin the list against what eventBridge.ts actually builds.
+ */
+describe("EVENT_TYPE_VARIABLES", () => {
+  it("covers every event type", () => {
+    for (const eventType of Object.keys(EVENT_TYPES)) {
+      expect(
+        EVENT_TYPE_VARIABLES[eventType as keyof typeof EVENT_TYPE_VARIABLES],
+        eventType,
+      ).toBeDefined();
+    }
+  });
+
+  it("only promises tokens the template engine knows", () => {
+    for (const [eventType, tokens] of Object.entries(EVENT_TYPE_VARIABLES)) {
+      for (const token of tokens) {
+        expect(TEMPLATE_VARIABLES, `${eventType} -> ${token}`).toHaveProperty(token);
+      }
+    }
+  });
+
+  it("promises no token twice", () => {
+    for (const [eventType, tokens] of Object.entries(EVENT_TYPE_VARIABLES)) {
+      expect(new Set(tokens).size, eventType).toBe(tokens.length);
+    }
+  });
+
+  it("always offers the guild tokens, which every context carries", () => {
+    for (const [eventType, tokens] of Object.entries(EVENT_TYPE_VARIABLES)) {
+      expect(tokens, eventType).toContain("{guild}");
+      expect(tokens, eventType).toContain("{guild.memberCount}");
+      expect(tokens, eventType).toContain("{timestamp}");
+    }
+  });
+
+  // buildMemberContext / buildBanContext / buildRoleContext set no channel at
+  // all, so a {channel} token on those events can only ever render "Unknown".
+  it("does not offer channel tokens on events with no channel", () => {
+    for (const eventType of [
+      "memberJoin",
+      "memberLeave",
+      "memberBanned",
+      "memberUnbanned",
+      "roleAdded",
+      "roleRemoved",
+      "nicknameChanged",
+      "memberTimeout",
+      "boostStart",
+      "boostEnd",
+    ]) {
+      const tokens = EVENT_TYPE_VARIABLES[eventType as keyof typeof EVENT_TYPE_VARIABLES];
+      expect(tokens, eventType).not.toContain("{channel}");
+      expect(tokens, eventType).not.toContain("{channel.name}");
+      expect(tokens, eventType).not.toContain("{channel.id}");
+    }
+  });
+
+  // buildChannelContext has no acting user — the gateway event does not carry one.
+  it("does not offer user tokens on channel events", () => {
+    for (const eventType of ["channelCreated", "channelDeleted"]) {
+      const tokens = EVENT_TYPE_VARIABLES[eventType as keyof typeof EVENT_TYPE_VARIABLES];
+      expect(tokens, eventType).not.toContain("{user}");
+      expect(tokens, eventType).not.toContain("{user.name}");
+    }
+  });
+
+  // threadCreate resolves only `ownerId`, never a username or tag.
+  it("offers only the id-based user tokens on threadCreated", () => {
+    const tokens = EVENT_TYPE_VARIABLES.threadCreated;
+    expect(tokens).toContain("{user}");
+    expect(tokens).toContain("{user.id}");
+    expect(tokens).not.toContain("{user.name}");
+    expect(tokens).not.toContain("{user.tag}");
+  });
+
+  it("offers the event-specific tokens each trigger actually sets", () => {
+    expect(EVENT_TYPE_VARIABLES.memberBanned).toContain("{ban.reason}");
+    expect(EVENT_TYPE_VARIABLES.nicknameChanged).toContain("{new.nickname}");
+    expect(EVENT_TYPE_VARIABLES.memberTimeout).toContain("{timeout.until}");
+    expect(EVENT_TYPE_VARIABLES.boostStart).toContain("{boost.since}");
+    expect(EVENT_TYPE_VARIABLES.reactionAdded).toContain("{emoji}");
+    expect(EVENT_TYPE_VARIABLES.voiceJoin).toContain("{voice.channel}");
+    expect(EVENT_TYPE_VARIABLES.threadCreated).toContain("{thread.name}");
+    expect(EVENT_TYPE_VARIABLES.messageCreated).toContain("{message.content}");
+  });
+
+  // Both maps describe the same underlying question — what does this event's
+  // context carry — so they must not disagree.
+  it("agrees with EVENT_CONDITION_SUPPORT about channels and users", () => {
+    for (const [eventType, subjects] of Object.entries(EVENT_CONDITION_SUPPORT)) {
+      const tokens = EVENT_TYPE_VARIABLES[eventType as keyof typeof EVENT_TYPE_VARIABLES];
+      expect(tokens.includes("{channel.id}"), `${eventType} channel`).toBe(
+        subjects.includes("channel"),
+      );
+      expect(tokens.includes("{user.id}"), `${eventType} user`).toBe(
+        subjects.includes("user"),
+      );
+    }
+  });
+});