From 1e6291616dd493c3ff07ddb40b37b4ca574551df Mon Sep 17 00:00:00 2001
From: Tanmay Deep Sharma <tanmaydeepsharma21@gmail.com>
Date: Wed, 15 Jul 2026 13:00:03 +0530
Subject: [PATCH] fix(automations): harden delayed rules against races, stale
 edits, and unsupported configs

- episode_key_for falls back to the incoming message's created_at when
  waiting_since is still nil (it is written after MESSAGE_CREATED dispatches),
  so awaiting-agent episodes no longer arm as awaiting_agent:0 and get skipped
  as episode_moved on the first customer message after an agent reply.
- Editing a rule's trigger, conditions, or actions (not just the delay) now
  discards its armed pending rows so they can't fire against a definition they
  were never armed under; deleting rather than skipping frees the episode slot
  so the new definition re-arms on the next matching event.
- The rule form only offers a delay when the config supports it: the delayed
  option is disabled with an explanation for attribute_changed conditions and
  for non-status conditions on conversation events, and the backend's specific
  error is surfaced on save instead of a generic message.
---
 .../dashboard/i18n/locale/en/automation.json  |  6 +-
 .../automation/AutomationRuleForm.vue         | 59 ++++++++++++++++++-
 .../dashboard/settings/automation/Index.vue   |  4 +-
 app/models/automation_rule.rb                 | 15 +++--
 .../automation_rule_pending_execution.rb      |  6 +-
 5 files changed, 78 insertions(+), 12 deletions(-)

diff --git a/app/javascript/dashboard/i18n/locale/en/automation.json b/app/javascript/dashboard/i18n/locale/en/automation.json
index 805674eba..7faf5d71f 100644
--- a/app/javascript/dashboard/i18n/locale/en/automation.json
+++ b/app/javascript/dashboard/i18n/locale/en/automation.json
@@ -38,7 +38,11 @@
             "DAYS": "Days"
           },
           "ERROR": "Delay must be between 10 minutes and 30 days",
-          "HELP_TEXT": "Delayed rules run only if the conditions still hold when the delay ends, and apply to conversations with activity after the rule is created."
+          "HELP_TEXT": "Delayed rules run only if the conditions still hold when the delay ends, and apply to conversations with activity after the rule is created.",
+          "RESTRICTED": {
+            "ATTRIBUTE_CHANGED": "A delay can't be used with an \"attribute changed\" condition, because the change can't be re-checked when the delay ends.",
+            "CONVERSATION_NON_STATUS": "For conversation events, a delay is only available when every condition uses the Status attribute."
+          }
         },
         "CONDITIONS": {
           "LABEL": "Conditions"
diff --git a/app/javascript/dashboard/routes/dashboard/settings/automation/AutomationRuleForm.vue b/app/javascript/dashboard/routes/dashboard/settings/automation/AutomationRuleForm.vue
index 3a6cc8a8b..c8370f6c8 100644
--- a/app/javascript/dashboard/routes/dashboard/settings/automation/AutomationRuleForm.vue
+++ b/app/javascript/dashboard/routes/dashboard/settings/automation/AutomationRuleForm.vue
@@ -197,6 +197,30 @@ const allowsDelayedExecution = computed(() =>
   isCloudFeatureEnabled(FEATURE_FLAGS.DELAYED_AUTOMATIONS)
 );
 
+// Mirrors the backend's execution_delay validations so we never offer an unsupported delay.
+const delayRestrictionReason = computed(() => {
+  const conditions = automation.value?.conditions || [];
+  if (
+    conditions.some(
+      condition => condition.filter_operator === 'attribute_changed'
+    )
+  ) {
+    return 'ATTRIBUTE_CHANGED';
+  }
+  if (
+    eventName.value !== 'message_created' &&
+    conditions.some(
+      condition =>
+        condition.attribute_key && condition.attribute_key !== 'status'
+    )
+  ) {
+    return 'CONVERSATION_NON_STATUS';
+  }
+  return null;
+});
+
+const isDelaySupported = computed(() => delayRestrictionReason.value === null);
+
 const executeMode = ref('immediate');
 const delayValue = ref(4);
 const delayUnit = ref('HOURS');
@@ -237,6 +261,13 @@ watch([executeMode, delayInMinutes], () => {
     executeMode.value === 'delayed' ? delayInMinutes.value : null;
 });
 
+// Editing the event/conditions into an unsupported shape reverts the delay to immediate.
+watch(isDelaySupported, supported => {
+  if (!supported && executeMode.value === 'delayed') {
+    executeMode.value = 'immediate';
+  }
+});
+
 watch(
   () => automation.value,
   () => {
@@ -361,11 +392,23 @@ defineExpose({ open, close });
             <input v-model="executeMode" type="radio" value="immediate" />
             {{ $t('AUTOMATION.ADD.FORM.EXECUTE.IMMEDIATELY') }}
           </label>
-          <label class="flex items-center gap-1.5 text-sm cursor-pointer">
-            <input v-model="executeMode" type="radio" value="delayed" />
+          <label
+            class="flex items-center gap-1.5 text-sm"
+            :class="
+              isDelaySupported
+                ? 'cursor-pointer'
+                : 'cursor-not-allowed opacity-50'
+            "
+          >
+            <input
+              v-model="executeMode"
+              type="radio"
+              value="delayed"
+              :disabled="!isDelaySupported"
+            />
             {{ $t('AUTOMATION.ADD.FORM.EXECUTE.AFTER_DELAY') }}
           </label>
-          <template v-if="executeMode === 'delayed'">
+          <template v-if="executeMode === 'delayed' && isDelaySupported">
             <input
               v-model.number="delayValue"
               type="number"
@@ -386,6 +429,16 @@ defineExpose({ open, close });
         <span v-if="errors.execution_delay" class="text-xs text-n-ruby-9">
           {{ $t('AUTOMATION.ADD.FORM.EXECUTE.ERROR') }}
         </span>
+        <p
+          v-else-if="!isDelaySupported"
+          class="text-xs text-n-amber-11 pt-1 mb-0"
+        >
+          {{
+            $t(
+              `AUTOMATION.ADD.FORM.EXECUTE.RESTRICTED.${delayRestrictionReason}`
+            )
+          }}
+        </p>
         <p
           v-else-if="executeMode === 'delayed'"
           class="text-xs text-n-slate-11 pt-1 mb-0"
diff --git a/app/javascript/dashboard/routes/dashboard/settings/automation/Index.vue b/app/javascript/dashboard/routes/dashboard/settings/automation/Index.vue
index 9ad6efd78..200a6695d 100644
--- a/app/javascript/dashboard/routes/dashboard/settings/automation/Index.vue
+++ b/app/javascript/dashboard/routes/dashboard/settings/automation/Index.vue
@@ -136,11 +136,11 @@ const submitAutomation = async (payload, mode) => {
     hideAddPopup();
     hideEditPopup();
   } catch (error) {
-    const errorMessage =
+    const fallbackMessage =
       mode === 'edit'
         ? t('AUTOMATION.EDIT.API.ERROR_MESSAGE')
         : t('AUTOMATION.ADD.API.ERROR_MESSAGE');
-    useAlert(errorMessage);
+    useAlert(error?.response?.data?.error || fallbackMessage);
   }
 };
 const toggleAutomation = async ({ id, name, status }) => {
diff --git a/app/models/automation_rule.rb b/app/models/automation_rule.rb
index 01ee19dad..592d8eb08 100644
--- a/app/models/automation_rule.rb
+++ b/app/models/automation_rule.rb
@@ -38,8 +38,10 @@ class AutomationRule < ApplicationRecord
   validate :execution_delay_supported_event
 
   after_update_commit :reauthorized!, if: -> { saved_change_to_conditions? }
-  # Rows already armed under the old delay must not fire on a config the rule no longer has.
-  after_update :cancel_stale_pending_executions, if: -> { saved_change_to_execution_delay? }
+  # Rows already armed under the old definition must not fire on a config the rule no longer
+  # has (different delay, trigger, conditions, or actions). Delete rather than skip so the
+  # freed episode slot lets the new definition re-arm on the next matching event.
+  after_update :discard_stale_pending_executions, if: :execution_config_changed?
 
   scope :active, -> { where(active: true) }
 
@@ -125,8 +127,13 @@ class AutomationRule < ApplicationRecord
     errors.add(:execution_delay, 'only supports status conditions for conversation-level events.')
   end
 
-  def cancel_stale_pending_executions
-    pending_executions.pending.find_each { |execution| execution.update!(status: :skipped, skip_reason: 'rule_edited') }
+  def execution_config_changed?
+    saved_change_to_execution_delay? || saved_change_to_event_name? ||
+      saved_change_to_conditions? || saved_change_to_actions?
+  end
+
+  def discard_stale_pending_executions
+    pending_executions.pending.delete_all
   end
 
   def validate_single_condition(condition)
diff --git a/app/models/automation_rule_pending_execution.rb b/app/models/automation_rule_pending_execution.rb
index 24d6a6924..3ee3bdc2e 100644
--- a/app/models/automation_rule_pending_execution.rb
+++ b/app/models/automation_rule_pending_execution.rb
@@ -64,8 +64,10 @@ class AutomationRulePendingExecution < ApplicationRecord
       # Sub-second precision so a resolve→reopen inside one second still ends the episode.
       "status:#{(conversation.status_changed_at.presence || conversation.created_at).to_f}"
     elsif message.incoming?
-      # waiting_since is cleared on agent/bot reply, so a reply invalidates this episode.
-      "awaiting_agent:#{conversation.waiting_since.to_i}"
+      # waiting_since is cleared on agent/bot reply, so a reply invalidates this episode. It is
+      # written just after MESSAGE_CREATED dispatches, so it can still be nil when this arms;
+      # fall back to the message's own created_at, which is exactly the value it becomes.
+      "awaiting_agent:#{(conversation.waiting_since.presence || message.created_at).to_i}"
     else
       # A new customer message changes the max incoming id, invalidating this episode.
       "reply_chase:#{conversation.messages.incoming.maximum(:id) || 0}"