Merge branch 'feature/cw-7513' into feature/cw-7513-specs

Make the wait's interrupt explicit (as Intercom does) so users can predict when the
rule runs. An "Ends the wait if …" line adapts to the rule's episode: status change
for conversation rules, customer reply for outgoing message rules, agent reply for
incoming ones — plus "or the conditions no longer match" universally. Behaviour is
unchanged; this only surfaces it.

app/controllers/api/v1/accounts/automation_rules_controller.rb

@@ -3,6 +3,7 @@ class Api::V1::Accounts::AutomationRulesController < Api::V1::Accounts::BaseCont
 
   before_action :check_authorization
   before_action :fetch_automation_rule, only: [:show, :update, :destroy, :clone]
+  before_action :ensure_execution_delay_allowed, only: [:create, :update]
 
   def index
     @automation_rules = Current.account.automation_rules
@@ -48,6 +49,9 @@ class Api::V1::Accounts::AutomationRulesController < Api::V1::Accounts::BaseCont
   def clone
     automation_rule = Current.account.automation_rules.find_by(id: params[:automation_rule_id])
     new_rule = automation_rule.dup
+    # dup copies execution_delay; drop it when the feature is off so clone can't create new
+    # delayed rules that create/update would reject.
+    new_rule.execution_delay = nil unless delayed_automations_enabled?
     new_rule.save!
     @automation_rule = new_rule
   end
@@ -55,13 +59,27 @@ class Api::V1::Accounts::AutomationRulesController < Api::V1::Accounts::BaseCont
   private
 
   def automation_rules_permit
+    permitted_attributes = [:name, :description, :event_name, :active]
+    permitted_attributes << :execution_delay if delayed_automations_enabled?
+
     params.permit(
-      :name, :description, :event_name, :active,
+      *permitted_attributes,
       conditions: [:attribute_key, :filter_operator, :query_operator, :custom_attribute_type, { values: [] }],
       actions: [:action_name, { action_params: [] }]
     )
   end
 
+  def ensure_execution_delay_allowed
+    return if delayed_automations_enabled?
+    return if params[:execution_delay].blank?
+
+    render json: { error: 'Delayed automations are not enabled for this account.' }, status: :unprocessable_entity
+  end
+
+  def delayed_automations_enabled?
+    Current.account.feature_enabled?('delayed_automations')
+  end
+
   def fetch_automation_rule
     @automation_rule = Current.account.automation_rules.find_by(id: params[:id])
   end

app/javascript/dashboard/featureFlags.js

@@ -14,6 +14,7 @@ export const FEATURE_FLAGS = {
   CRM: 'crm',
   CUSTOM_ATTRIBUTES: 'custom_attributes',
   DATA_IMPORT: 'data_import',
+  DELAYED_AUTOMATIONS: 'delayed_automations',
   API_AND_WEBHOOKS: 'api_and_webhooks',
   INBOX_MANAGEMENT: 'inbox_management',
   INTEGRATIONS: 'integrations',

app/javascript/dashboard/helper/automationHelper.js

@@ -208,6 +208,12 @@ export const generateAutomationPayload = payload => {
   return automation;
 };
 
+export const formatDelay = minutes => {
+  if (minutes % 1440 === 0) return `${minutes / 1440}d`;
+  if (minutes % 60 === 0) return `${minutes / 60}h`;
+  return `${minutes}m`;
+};
+
 export const isCustomAttribute = (attrs, key) => {
   return attrs.find(attr => attr.key === key);
 };

app/javascript/dashboard/i18n/locale/en/automation.json

@@ -28,6 +28,35 @@
           "PLACEHOLDER": "Please select one",
           "ERROR": "Event is required"
         },
+        "EXECUTE": {
+          "LABEL": "Delayed execution",
+          "AFTER_DELAY": "Run after",
+          "UNITS": {
+            "MINUTES": "Minutes",
+            "HOURS": "Hours",
+            "DAYS": "Days"
+          },
+          "ERROR": "Delay must be between 10 minutes and 30 days",
+          "ENDS_IF_LABEL": "Won't run if",
+          "ENDS_IF": {
+            "STATUS": "the conversation's status changes, or its conditions no longer match.",
+            "CUSTOMER_REPLY": "the customer replies, or the conditions no longer match.",
+            "AGENT_REPLY": "an agent replies, or the conditions no longer match.",
+            "GENERIC": "there is a new reply on the conversation, or the conditions no longer match."
+          },
+          "HELP_TEXT": "Only applies to conversations with activity after the rule is created."
+        },
+        "TRIGGER": {
+          "LABEL": "Trigger",
+          "WHEN_LABEL": "When",
+          "STATUS_LABEL": "Status is",
+          "INBOX_LABEL": "Inbox",
+          "OPTIONS": {
+            "CUSTOMER_UNRESPONSIVE": "Customer unresponsive",
+            "AGENT_UNRESPONSIVE": "Teammate unresponsive",
+            "CONVERSATION_STATUS": "Conversation in a status"
+          }
+        },
         "CONDITIONS": {
           "LABEL": "Conditions"
         },
@@ -49,7 +78,13 @@
         "CREATED_ON": "Created on",
         "ACTIONS": "Actions"
       },
-      "404": "No automation rules found"
+      "404": "No automation rules found",
+      "SECTIONS": {
+        "INSTANT": "Automations",
+        "DELAYED": "Delayed execution"
+      },
+      "DELAY_BADGE": "Runs after {delay}",
+      "DELAY_DISABLED_BANNER": "Delayed execution is disabled for this account. Delayed rules won't run until it is enabled again."
     },
     "DELETE": {
       "TITLE": "Delete Automation Rule",

app/javascript/dashboard/routes/dashboard/settings/automation/AddAutomationRule.vue

@@ -10,6 +10,7 @@ const START_VALUE = {
   name: null,
   description: null,
   event_name: 'conversation_created',
+  execution_delay: null,
   conditions: [
     {
       attribute_key: 'status',

app/javascript/dashboard/routes/dashboard/settings/automation/AutomationRuleForm.vue

@@ -6,6 +6,11 @@ import { useOperators } from 'dashboard/components-next/filter/operators';
 import ConditionRow from 'dashboard/components-next/filter/ConditionRow.vue';
 import AutomationActionInput from 'dashboard/components/widgets/AutomationActionInput.vue';
 import NextButton from 'dashboard/components-next/button/Button.vue';
+import ToggleSwitch from 'dashboard/components-next/switch/Switch.vue';
+import FilterSelect from 'dashboard/components-next/filter/inputs/FilterSelect.vue';
+import MultiSelect from 'dashboard/components-next/filter/inputs/MultiSelect.vue';
+import DurationInput from 'dashboard/components-next/input/DurationInput.vue';
+import { DURATION_UNITS } from 'dashboard/components-next/input/constants';
 import Dialog from 'dashboard/components-next/dialog/Dialog.vue';
 import {
   generateAutomationPayload,
@@ -14,6 +19,7 @@ import {
   showActionInput,
 } from 'dashboard/helper/automationHelper';
 import { validateAutomation } from 'dashboard/helper/validations';
+import { FEATURE_FLAGS } from 'dashboard/featureFlags';
 import { AUTOMATION_RULE_EVENTS, AUTOMATION_ACTION_TYPES } from './constants';
 
 const props = defineProps({
@@ -71,6 +77,28 @@ const INPUT_TYPE_MAP = {
   date: 'date',
 };
 
+const DEFAULT_DELAY_MINUTES = 240; // 4 hours
+const MIN_DELAY_MINUTES = 10;
+const MAX_DELAY_MINUTES = 43200; // 30 days
+// A delayed rule is expressed as one meaningful trigger instead of a raw event + conditions. Each
+// trigger maps to the automation's event_name plus a preset condition: message_type for the two
+// unresponsive cases (reply-chase / awaiting-agent), or a chosen status for conversation_updated.
+const DELAYED_TRIGGERS = [
+  { key: 'conversation_status', eventName: 'conversation_updated' },
+  {
+    key: 'customer_unresponsive',
+    eventName: 'message_created',
+    messageType: 'outgoing',
+  },
+  {
+    key: 'agent_unresponsive',
+    eventName: 'message_created',
+    messageType: 'incoming',
+  },
+];
+const DEFAULT_TRIGGER = DELAYED_TRIGGERS[0].key;
+const DEFAULT_TRIGGER_STATUS = 'pending';
+
 const { t } = useI18n();
 const { isCloudFeatureEnabled } = useAccount();
 const { operators } = useOperators();
@@ -78,6 +106,7 @@ const { operators } = useOperators();
 const dialogRef = ref(null);
 const conditionsRef = useTemplateRef('conditionsRef');
 const errors = ref({});
+const isDelayed = ref(false);
 
 const isEditMode = computed(() => props.mode === 'edit');
 
@@ -184,6 +213,167 @@ const hasActionErrors = computed(() =>
   Object.keys(errors.value).some(key => key.startsWith('action_'))
 );
 
+const allowsDelayedExecution = computed(() =>
+  isCloudFeatureEnabled(FEATURE_FLAGS.DELAYED_AUTOMATIONS)
+);
+
+// Trigger controls for the delayed flow. They own event_name + conditions while the wait is on.
+// selectedTrigger / triggerStatus are plain values (FilterSelect); triggerInboxes is an array of
+// { id, name } (MultiSelect) — empty means the rule applies to every inbox.
+const selectedTrigger = ref(DEFAULT_TRIGGER);
+const triggerStatus = ref(DEFAULT_TRIGGER_STATUS);
+const triggerInboxes = ref([]);
+
+const isStatusTrigger = computed(
+  () => selectedTrigger.value === 'conversation_status'
+);
+
+// FilterSelect expects { label, value }.
+const statusSelectOptions = computed(() =>
+  (props.getConditionDropdownValues('status') || [])
+    .filter(option => option.id !== 'all')
+    .map(option => ({ value: option.id, label: option.name }))
+);
+
+const triggerSelectOptions = computed(() =>
+  DELAYED_TRIGGERS.map(trigger => ({
+    value: trigger.key,
+    label: t(
+      `AUTOMATION.ADD.FORM.TRIGGER.OPTIONS.${trigger.key.toUpperCase()}`
+    ),
+  }))
+);
+
+// MultiSelect expects (and returns) { id, name } options.
+const inboxOptions = computed(
+  () => props.getConditionDropdownValues('inbox_id') || []
+);
+
+// What ends the wait, mirroring the backend episode that arms the rule. Shown to the user so
+// they can predict when the rule runs. Conversation rules key on status; message rules key on
+// the reply that ends the wait (customer reply for outgoing, agent reply for incoming).
+const waitEndsKey = computed(() => {
+  if (eventName.value !== 'message_created') return 'STATUS';
+  const messageType = (automation.value?.conditions || []).find(
+    condition => condition.attribute_key === 'message_type'
+  );
+  const raw = Array.isArray(messageType?.values)
+    ? messageType.values[0]
+    : messageType?.values;
+  // Raw create-mode values are strings ('outgoing'); edit-mode values are option objects.
+  const value = raw && typeof raw === 'object' ? raw.id : raw;
+  if (value === 'outgoing') return 'CUSTOMER_REPLY';
+  if (value === 'incoming') return 'AGENT_REPLY';
+  return 'GENERIC';
+});
+
+// DurationInput holds the wait in minutes and clamps to [MIN, MAX]; the unit is display-only.
+const delayMinutes = ref(DEFAULT_DELAY_MINUTES);
+const delayUnit = ref(DURATION_UNITS.HOURS);
+
+const executionDelayInvalid = computed(
+  () => isDelayed.value && !Number.isFinite(delayMinutes.value)
+);
+
+// Show the wait in the largest whole unit (240 min → 4 hours). Passed in by open() rather than
+// read from `automation`, whose model prop only settles a tick later.
+const syncDelayFromDelay = delay => {
+  isDelayed.value = Boolean(delay);
+  const minutes = delay || DEFAULT_DELAY_MINUTES;
+  if (minutes % 1440 === 0) delayUnit.value = DURATION_UNITS.DAYS;
+  else if (minutes % 60 === 0) delayUnit.value = DURATION_UNITS.HOURS;
+  else delayUnit.value = DURATION_UNITS.MINUTES;
+  delayMinutes.value = minutes;
+};
+
+watch([isDelayed, delayMinutes], () => {
+  if (!automation.value || !allowsDelayedExecution.value) return;
+  automation.value.execution_delay = isDelayed.value
+    ? delayMinutes.value
+    : null;
+});
+
+const buildTriggerCondition = (attributeKey, values) => ({
+  attribute_key: attributeKey,
+  filter_operator: 'equal_to',
+  values,
+  query_operator: 'and',
+  custom_attribute_type: '',
+});
+
+// Write the selected trigger (plus optional inbox scope) onto the rule's event_name + conditions.
+const applyDelayedTrigger = () => {
+  const trigger = DELAYED_TRIGGERS.find(
+    item => item.key === selectedTrigger.value
+  );
+  if (!automation.value || !trigger) return;
+  automation.value.event_name = trigger.eventName;
+  const conditions = [
+    trigger.messageType
+      ? buildTriggerCondition('message_type', trigger.messageType)
+      : buildTriggerCondition('status', triggerStatus.value),
+  ];
+  if (triggerInboxes.value.length) {
+    conditions.push(
+      buildTriggerCondition(
+        'inbox_id',
+        triggerInboxes.value.map(inbox => inbox.id)
+      )
+    );
+  }
+  automation.value.conditions = conditions;
+};
+
+// A single value is a raw string in create mode and an option object ({ id }) after edit-mode
+// formatting; return its plain value either way.
+const rawConditionValue = condition => {
+  const raw = Array.isArray(condition?.values)
+    ? condition.values[0]
+    : condition?.values;
+  return raw && typeof raw === 'object' ? raw.id : raw;
+};
+
+// Populate the trigger controls from an existing delayed rule when editing.
+const hydrateTriggerFromAutomation = () => {
+  const conditions = automation.value?.conditions || [];
+  const byKey = key => conditions.find(c => c.attribute_key === key);
+  const messageType = rawConditionValue(byKey('message_type'));
+  if (messageType === 'incoming') selectedTrigger.value = 'agent_unresponsive';
+  else if (messageType === 'outgoing')
+    selectedTrigger.value = 'customer_unresponsive';
+  else {
+    selectedTrigger.value = 'conversation_status';
+    triggerStatus.value =
+      rawConditionValue(byKey('status')) || DEFAULT_TRIGGER_STATUS;
+  }
+  const inboxValues = byKey('inbox_id')?.values || [];
+  const inboxIds = inboxValues.map(value =>
+    value && typeof value === 'object' ? value.id : value
+  );
+  triggerInboxes.value = inboxOptions.value.filter(inbox =>
+    inboxIds.includes(inbox.id)
+  );
+};
+
+// Turning the wait on (create) sets the default trigger's event + conditions.
+watch(isDelayed, delayed => {
+  if (delayed && automation.value && !isEditMode.value) applyDelayedTrigger();
+});
+
+// Any trigger-control change re-derives event_name + conditions. After hydration this simply
+// re-writes the same values, so it stays idempotent (no reference change → no loop).
+watch([selectedTrigger, triggerStatus, triggerInboxes], () => {
+  if (isDelayed.value) applyDelayedTrigger();
+});
+
+// Opening an existing delayed rule mirrors its event/conditions into the trigger controls.
+watch(
+  () => automation.value,
+  () => {
+    if (isDelayed.value && automation.value) hydrateTriggerFromAutomation();
+  }
+);
+
 watch(
   () => automation.value,
   () => {
@@ -216,8 +406,9 @@ const syncCustomAttributeTypes = () => {
   });
 };
 
-const open = () => {
+const open = (executionDelay = null) => {
   resetValidation();
+  syncDelayFromDelay(executionDelay);
   dialogRef.value?.open();
 };
 
@@ -230,8 +421,13 @@ const emitSaveAutomation = () => {
   syncCustomAttributeTypes();
   const conditionsValid = isConditionsValid();
   errors.value = validateAutomation(automation.value);
+  if (allowsDelayedExecution.value && executionDelayInvalid.value) {
+    errors.value.execution_delay = true;
+  }
   if (Object.keys(errors.value).length === 0 && conditionsValid) {
     const payload = generateAutomationPayload(automation.value);
+    // The API rejects the param when the feature is off; existing values are kept server-side.
+    if (!allowsDelayedExecution.value) delete payload.execution_delay;
     emit('save', payload, props.mode);
   }
 };
@@ -266,84 +462,163 @@ defineExpose({ open, close });
         :error="errors.description ? $t('AUTOMATION.ADD.FORM.DESC.ERROR') : ''"
         :placeholder="$t('AUTOMATION.ADD.FORM.DESC.PLACEHOLDER')"
       />
-      <div class="mb-6">
-        <label :class="{ error: errors.event_name }">
-          {{ $t('AUTOMATION.ADD.FORM.EVENT.LABEL') }}
-          <select
-            v-model="automation.event_name"
-            class="m-0"
-            @change="onEventChange()"
-          >
-            <option
-              v-for="event in automationRuleEvents"
-              :key="event.key"
-              :value="event.key"
-            >
-              {{ event.value }}
-            </option>
-          </select>
-          <span v-if="errors.event_name" class="message">
-            {{ $t('AUTOMATION.ADD.FORM.EVENT.ERROR') }}
+      <!-- Wait Start (choose the delay first, then the trigger) -->
+      <div v-if="allowsDelayedExecution" class="mb-6">
+        <div class="flex items-center justify-between gap-4">
+          <label class="mb-0" :class="{ error: errors.execution_delay }">
+            {{ $t('AUTOMATION.ADD.FORM.EXECUTE.LABEL') }}
+          </label>
+          <ToggleSwitch v-model="isDelayed" />
+        </div>
+        <div v-if="isDelayed" class="flex flex-wrap items-center gap-2 mt-2">
+          <span class="text-sm text-n-slate-11">
+            {{ $t('AUTOMATION.ADD.FORM.EXECUTE.AFTER_DELAY') }}
           </span>
-        </label>
-        <p
-          v-if="!isEditMode && hasAutomationMutated"
-          class="text-xs text-right text-n-teal-10 pt-1"
-        >
-          {{ $t('AUTOMATION.FORM.RESET_MESSAGE') }}
-        </p>
-      </div>
-      <!-- Conditions Start -->
-      <section class="mb-5">
-        <label>
-          {{ $t('AUTOMATION.ADD.FORM.CONDITIONS.LABEL') }}
-        </label>
-        <ul
-          class="grid gap-4 list-none p-3 mb-4 outline outline-1 rounded-xl -outline-offset-1"
-          :class="
-            hasConditionErrors
-              ? 'outline-n-ruby-5 bg-n-ruby-2/50'
-              : 'outline-n-weak dark:outline-n-strong'
-          "
-        >
-          <template v-for="(condition, i) in automation.conditions" :key="i">
-            <ConditionRow
-              v-if="i === 0"
-              ref="conditionsRef"
-              v-model:attribute-key="automation.conditions[i].attribute_key"
-              v-model:filter-operator="automation.conditions[i].filter_operator"
-              v-model:values="automation.conditions[i].values"
-              :filter-types="filterTypes"
-              :show-query-operator="false"
-              @remove="removeFilter(i)"
-            />
-            <ConditionRow
-              v-else
-              ref="conditionsRef"
-              v-model:attribute-key="automation.conditions[i].attribute_key"
-              v-model:filter-operator="automation.conditions[i].filter_operator"
-              v-model:query-operator="
-                automation.conditions[i - 1].query_operator
-              "
-              v-model:values="automation.conditions[i].values"
-              :filter-types="filterTypes"
-              show-query-operator
-              @remove="removeFilter(i)"
-            />
-          </template>
-          <div>
-            <NextButton
-              icon="i-lucide-plus"
-              blue
-              faded
-              sm
-              :label="$t('AUTOMATION.ADD.CONDITION_BUTTON_LABEL')"
-              @click="appendNewCondition"
+          <div class="flex items-center gap-2 w-64">
+            <DurationInput
+              v-model="delayMinutes"
+              v-model:unit="delayUnit"
+              :min="MIN_DELAY_MINUTES"
+              :max="MAX_DELAY_MINUTES"
             />
           </div>
-        </ul>
-      </section>
-      <!-- Conditions End -->
+        </div>
+        <span
+          v-if="isDelayed && executionDelayInvalid"
+          class="text-xs text-n-ruby-9"
+        >
+          {{ $t('AUTOMATION.ADD.FORM.EXECUTE.ERROR') }}
+        </span>
+      </div>
+      <!-- Wait End -->
+      <!-- Delayed trigger: a curated event + condition, in place of raw Event/Conditions -->
+      <div v-if="isDelayed" class="mb-6">
+        <label class="mb-1">
+          {{ $t('AUTOMATION.ADD.FORM.TRIGGER.LABEL') }}
+        </label>
+        <div
+          class="flex flex-col gap-3 p-4 outline outline-1 -outline-offset-1 rounded-xl outline-n-weak dark:outline-n-strong"
+        >
+          <div class="flex items-center gap-3 min-h-8">
+            <span class="w-20 shrink-0 text-sm text-n-slate-11">
+              {{ $t('AUTOMATION.ADD.FORM.TRIGGER.WHEN_LABEL') }}
+            </span>
+            <FilterSelect
+              v-model="selectedTrigger"
+              :options="triggerSelectOptions"
+            />
+          </div>
+          <div v-if="isStatusTrigger" class="flex items-center gap-3 min-h-8">
+            <span class="w-20 shrink-0 text-sm text-n-slate-11">
+              {{ $t('AUTOMATION.ADD.FORM.TRIGGER.STATUS_LABEL') }}
+            </span>
+            <FilterSelect
+              v-model="triggerStatus"
+              :options="statusSelectOptions"
+            />
+          </div>
+          <div class="flex items-center gap-3 min-h-8">
+            <span class="w-20 shrink-0 text-sm text-n-slate-11">
+              {{ $t('AUTOMATION.ADD.FORM.TRIGGER.INBOX_LABEL') }}
+            </span>
+            <MultiSelect v-model="triggerInboxes" :options="inboxOptions" />
+          </div>
+        </div>
+        <p class="text-xs text-n-slate-11 pt-2 mb-0">
+          <span class="text-n-slate-12 font-medium">
+            {{ $t('AUTOMATION.ADD.FORM.EXECUTE.ENDS_IF_LABEL') }}
+          </span>
+          {{ $t(`AUTOMATION.ADD.FORM.EXECUTE.ENDS_IF.${waitEndsKey}`) }}
+        </p>
+        <p class="text-xs text-n-slate-11 pt-1 mb-0">
+          {{ $t('AUTOMATION.ADD.FORM.EXECUTE.HELP_TEXT') }}
+        </p>
+      </div>
+      <!-- Instant flow: raw Event + Conditions -->
+      <template v-else>
+        <div class="mb-6">
+          <label :class="{ error: errors.event_name }">
+            {{ $t('AUTOMATION.ADD.FORM.EVENT.LABEL') }}
+            <select
+              v-model="automation.event_name"
+              class="m-0"
+              @change="onEventChange()"
+            >
+              <option
+                v-for="event in automationRuleEvents"
+                :key="event.key"
+                :value="event.key"
+              >
+                {{ event.value }}
+              </option>
+            </select>
+            <span v-if="errors.event_name" class="message">
+              {{ $t('AUTOMATION.ADD.FORM.EVENT.ERROR') }}
+            </span>
+          </label>
+          <p
+            v-if="!isEditMode && hasAutomationMutated"
+            class="text-xs text-right text-n-teal-10 pt-1"
+          >
+            {{ $t('AUTOMATION.FORM.RESET_MESSAGE') }}
+          </p>
+        </div>
+        <!-- Conditions Start -->
+        <section class="mb-5">
+          <label>
+            {{ $t('AUTOMATION.ADD.FORM.CONDITIONS.LABEL') }}
+          </label>
+          <ul
+            class="grid gap-4 list-none p-3 mb-4 outline outline-1 rounded-xl -outline-offset-1"
+            :class="
+              hasConditionErrors
+                ? 'outline-n-ruby-5 bg-n-ruby-2/50'
+                : 'outline-n-weak dark:outline-n-strong'
+            "
+          >
+            <template v-for="(condition, i) in automation.conditions" :key="i">
+              <ConditionRow
+                v-if="i === 0"
+                ref="conditionsRef"
+                v-model:attribute-key="automation.conditions[i].attribute_key"
+                v-model:filter-operator="
+                  automation.conditions[i].filter_operator
+                "
+                v-model:values="automation.conditions[i].values"
+                :filter-types="filterTypes"
+                :show-query-operator="false"
+                @remove="removeFilter(i)"
+              />
+              <ConditionRow
+                v-else
+                ref="conditionsRef"
+                v-model:attribute-key="automation.conditions[i].attribute_key"
+                v-model:filter-operator="
+                  automation.conditions[i].filter_operator
+                "
+                v-model:query-operator="
+                  automation.conditions[i - 1].query_operator
+                "
+                v-model:values="automation.conditions[i].values"
+                :filter-types="filterTypes"
+                show-query-operator
+                @remove="removeFilter(i)"
+              />
+            </template>
+            <div>
+              <NextButton
+                icon="i-lucide-plus"
+                blue
+                faded
+                sm
+                :label="$t('AUTOMATION.ADD.CONDITION_BUTTON_LABEL')"
+                @click="appendNewCondition"
+              />
+            </div>
+          </ul>
+        </section>
+        <!-- Conditions End -->
+      </template>
       <!-- Actions Start -->
       <section>
         <label>

app/javascript/dashboard/routes/dashboard/settings/automation/AutomationRuleRow.vue

@@ -1,6 +1,7 @@
 <script setup>
 import { computed } from 'vue';
 import { messageStamp } from 'shared/helpers/timeHelper';
+import { formatDelay } from 'dashboard/helper/automationHelper';
 import Button from 'dashboard/components-next/button/Button.vue';
 import ToggleSwitch from 'dashboard/components-next/switch/Switch.vue';
 import { BaseTableRow, BaseTableCell } from 'dashboard/components-next/table';
@@ -43,6 +44,16 @@ const automationActive = computed({
           <span class="text-body-main text-n-slate-12 truncate">
             {{ automation.name }}
           </span>
+          <span
+            v-if="automation.execution_delay"
+            class="text-xs px-1.5 py-0.5 rounded-md bg-n-alpha-2 text-n-slate-11 whitespace-nowrap flex-shrink-0"
+          >
+            {{
+              $t('AUTOMATION.LIST.DELAY_BADGE', {
+                delay: formatDelay(automation.execution_delay),
+              })
+            }}
+          </span>
           <div class="w-px h-3 rounded-lg bg-n-weak flex-shrink-0" />
           <span class="text-body-main text-n-slate-11 truncate">
             {{ automation.description }}

app/javascript/dashboard/routes/dashboard/settings/automation/EditAutomationRule.vue

@@ -34,29 +34,33 @@ const {
 
 const { formatAutomation } = useEditableAutomation();
 
-const open = () => formRef.value?.open();
+const syncAutomationFromSelected = (source = props.selectedResponse) => {
+  if (!source?.conditions) return;
+
+  manifestCustomAttributes();
+  automation.value = formatAutomation(
+    source,
+    allCustomAttributes.value,
+    automationTypes,
+    AUTOMATION_ACTION_TYPES
+  );
+};
+
+// Format from the rule passed to open(): the prop updates a tick later, so at open() time
+// automation still holds the previously selected rule (its execution_delay hydrates the form).
+const open = rule => {
+  syncAutomationFromSelected(rule);
+  formRef.value?.open(rule?.execution_delay);
+};
 const close = () => formRef.value?.close();
 
 const onSave = (payload, mode) => {
   emit('saveAutomation', payload, mode);
 };
 
-watch(
-  () => props.selectedResponse,
-  value => {
-    if (!value?.conditions) return;
-
-    manifestCustomAttributes();
-
-    automation.value = formatAutomation(
-      value,
-      allCustomAttributes.value,
-      automationTypes,
-      AUTOMATION_ACTION_TYPES
-    );
-  },
-  { immediate: true }
-);
+watch(() => props.selectedResponse, syncAutomationFromSelected, {
+  immediate: true,
+});
 
 defineExpose({ open, close });
 </script>

app/javascript/dashboard/routes/dashboard/settings/automation/Index.vue

@@ -35,6 +35,31 @@ const filteredRecords = computed(() => {
   if (!query) return records.value;
   return picoSearch(records.value, query, ['name', 'description']);
 });
+
+// Delayed (wait) rules run on a different lifecycle, so list them in their own section.
+const hasDelayedRecords = computed(() =>
+  records.value.some(automation => automation.execution_delay)
+);
+
+const sections = computed(() => {
+  const instant = [];
+  const delayed = [];
+  filteredRecords.value.forEach(automation =>
+    (automation.execution_delay ? delayed : instant).push(automation)
+  );
+  return [
+    {
+      key: 'instant',
+      label: t('AUTOMATION.LIST.SECTIONS.INSTANT'),
+      items: instant,
+    },
+    {
+      key: 'delayed',
+      label: t('AUTOMATION.LIST.SECTIONS.DELAYED'),
+      items: delayed,
+    },
+  ].filter(section => section.items.length);
+});
 const uiFlags = computed(() => getters['automations/getUIFlags'].value);
 const accountId = computed(() => getters.getCurrentAccountId.value);
 
@@ -52,6 +77,14 @@ const isSLAEnabled = computed(() =>
   getters['accounts/isFeatureEnabledonAccount'].value(accountId.value, 'sla')
 );
 
+const showDelayDisabledBanner = computed(
+  () =>
+    !getters['accounts/isFeatureEnabledonAccount'].value(
+      accountId.value,
+      'delayed_automations'
+    ) && records.value.some(automation => automation.execution_delay)
+);
+
 onMounted(() => {
   store.dispatch('inboxes/get');
   store.dispatch('agents/get');
@@ -74,7 +107,7 @@ const hideAddPopup = () => {
 
 const openEditPopup = response => {
   selectedAutomation.value = { ...response };
-  editDialogRef.value?.open();
+  editDialogRef.value?.open(response);
 };
 const hideEditPopup = () => {
   editDialogRef.value?.close();
@@ -128,11 +161,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 }) => {
@@ -212,25 +245,49 @@ const tableHeaders = computed(() => {
       </BaseSettingsHeader>
     </template>
     <template #body>
+      <div
+        v-if="showDelayDisabledBanner"
+        class="px-4 py-3 mb-4 text-sm rounded-lg bg-n-amber-3 text-n-amber-12"
+      >
+        {{ $t('AUTOMATION.LIST.DELAY_DISABLED_BANNER') }}
+      </div>
+      <template v-if="filteredRecords.length">
+        <div
+          v-for="section in sections"
+          :key="section.key"
+          class="mb-6 last:mb-0"
+        >
+          <h4
+            v-if="hasDelayedRecords"
+            class="mb-2 text-sm font-medium text-n-slate-11"
+          >
+            {{ section.label }}
+          </h4>
+          <BaseTable :headers="tableHeaders" :items="section.items">
+            <template #row="{ items }">
+              <AutomationRuleRow
+                v-for="automation in items"
+                :key="automation.id"
+                :automation="automation"
+                :loading="loading[automation.id]"
+                @clone="cloneAutomation"
+                @toggle="toggleAutomation"
+                @edit="openEditPopup"
+                @delete="openDeletePopup"
+              />
+            </template>
+          </BaseTable>
+        </div>
+      </template>
       <BaseTable
+        v-else
         :headers="tableHeaders"
-        :items="filteredRecords"
+        :items="[]"
         :no-data-message="
           searchQuery ? $t('AUTOMATION.NO_RESULTS') : $t('AUTOMATION.LIST.404')
         "
       >
-        <template #row="{ items }">
-          <AutomationRuleRow
-            v-for="automation in items"
-            :key="automation.id"
-            :automation="automation"
-            :loading="loading[automation.id]"
-            @clone="cloneAutomation"
-            @toggle="toggleAutomation"
-            @edit="openEditPopup"
-            @delete="openDeletePopup"
-          />
-        </template>
+        <template #row />
       </BaseTable>
     </template>
 

app/jobs/automation_rules/process_pending_execution_job.rb

@@ -0,0 +1,65 @@
+class AutomationRules::ProcessPendingExecutionJob < ApplicationJob
+  queue_as :medium
+
+  discard_on ActiveJob::DeserializationError
+
+  def perform(pending_execution)
+    return if delayed_automations_disabled?
+    # Account flag off pauses (not skips): leave the row pending so re-enabling resumes it.
+    return unless pending_execution.account.feature_enabled?('delayed_automations')
+    # Atomic claim: a duplicate enqueue (overlapping sweep or stale reclaim) loses here and returns.
+    return unless pending_execution.claim!
+
+    skip_reason = skip_reason_for(pending_execution)
+    return pending_execution.update!(status: :skipped, skip_reason: skip_reason) if skip_reason
+
+    execute(pending_execution)
+  rescue StandardError => e
+    # Row stays `processing`; the next sweep reclaims and retries it once the lock goes stale.
+    ChatwootExceptionTracker.new(e, account: pending_execution.account).capture_exception
+  end
+
+  private
+
+  def skip_reason_for(pending_execution)
+    return 'expired' if pending_execution.due_at < AutomationRulePendingExecution::DUE_WINDOW.ago
+
+    structural_skip_reason(pending_execution) || behavioral_skip_reason(pending_execution)
+  end
+
+  def structural_skip_reason(pending_execution)
+    rule = pending_execution.automation_rule
+    return 'rule_inactive' if rule.nil? || !rule.active?
+    return 'conversation_gone' if pending_execution.conversation.nil?
+
+    nil
+  end
+
+  def behavioral_skip_reason(pending_execution)
+    return 'episode_moved' unless pending_execution.episode_current?
+    return AutomationRulePendingExecution::CONDITIONS_CHANGED_SKIP unless conditions_still_match?(pending_execution)
+
+    nil
+  end
+
+  def conditions_still_match?(pending_execution)
+    AutomationRules::ConditionsFilterService.new(
+      pending_execution.automation_rule,
+      pending_execution.conversation,
+      { message: pending_execution.message }
+    ).perform.present?
+  end
+
+  def execute(pending_execution)
+    AutomationRules::ActionService.new(
+      pending_execution.automation_rule,
+      pending_execution.account,
+      pending_execution.conversation
+    ).perform
+    pending_execution.update!(status: :executed)
+  end
+
+  def delayed_automations_disabled?
+    GlobalConfig.get('DISABLE_DELAYED_AUTOMATIONS')['DISABLE_DELAYED_AUTOMATIONS']
+  end
+end

app/jobs/automation_rules/resume_paused_executions_job.rb

@@ -0,0 +1,11 @@
+class AutomationRules::ResumePausedExecutionsJob < ApplicationJob
+  # Enqueued the moment the account flag flips back on, ahead of the next sweep, so overdue rows
+  # are rescheduled before that sweep's per-row jobs could mark them expired.
+  queue_as :medium
+
+  discard_on ActiveJob::DeserializationError
+
+  def perform(account)
+    AutomationRulePendingExecution.reschedule_paused(account)
+  end
+end

app/jobs/automation_rules/trigger_pending_executions_job.rb

@@ -0,0 +1,32 @@
+class AutomationRules::TriggerPendingExecutionsJob < ApplicationJob
+  queue_as :scheduled_jobs
+
+  DEFAULT_SWEEP_LIMIT = 1000
+
+  def perform
+    return if delayed_automations_disabled?
+
+    started_at = Time.current
+    purged = AutomationRulePendingExecution.purge_terminal!
+
+    rows = AutomationRulePendingExecution.sweepable.for_enabled_accounts.order(:due_at).limit(sweep_limit).to_a
+    rows.each { |row| AutomationRules::ProcessPendingExecutionJob.perform_later(row) }
+
+    log_summary(enqueued: rows.size, capped: rows.size >= sweep_limit, purged: purged, started_at: started_at)
+  end
+
+  private
+
+  def delayed_automations_disabled?
+    GlobalConfig.get('DISABLE_DELAYED_AUTOMATIONS')['DISABLE_DELAYED_AUTOMATIONS']
+  end
+
+  def sweep_limit
+    (InstallationConfig.find_by(name: 'AUTOMATION_PENDING_EXECUTIONS_SWEEP_LIMIT')&.value || DEFAULT_SWEEP_LIMIT).to_i
+  end
+
+  def log_summary(enqueued:, capped:, purged:, started_at:)
+    summary = { event: 'completed', enqueued: enqueued, capped: capped, purged: purged, duration_ms: ((Time.current - started_at) * 1000).round }
+    Rails.logger.info("[AutomationRules::TriggerPendingExecutionsJob] #{summary.to_json}")
+  end
+end

app/jobs/trigger_scheduled_items_job.rb

@@ -19,6 +19,9 @@ class TriggerScheduledItemsJob < ApplicationJob
 
     # Job to sync whatsapp templates
     Channels::Whatsapp::TemplatesSyncSchedulerJob.perform_later
+
+    # Job to trigger pending executions
+    AutomationRules::TriggerPendingExecutionsJob.perform_later
   end
 end
 

app/listeners/automation_rule_listener.rb

@@ -30,7 +30,7 @@ class AutomationRuleListener < BaseListener
     rules.each do |rule|
       conditions_match = ::AutomationRules::ConditionsFilterService.new(rule, message.conversation,
                                                                         { message: message, changed_attributes: changed_attributes }).perform
-      ::AutomationRules::ActionService.new(rule, account, message.conversation).perform if conditions_match.present?
+      execute_rule(rule, account, message.conversation, message: message) if conditions_match.present?
     end
   end
 
@@ -52,7 +52,20 @@ class AutomationRuleListener < BaseListener
 
     rules.each do |rule|
       conditions_match = ::AutomationRules::ConditionsFilterService.new(rule, conversation, { changed_attributes: changed_attributes }).perform
-      AutomationRules::ActionService.new(rule, account, conversation).perform if conditions_match.present?
+      execute_rule(rule, account, conversation) if conditions_match.present?
+    end
+  end
+
+  # Delayed rules record a pending execution instead of acting; the sweep re-checks and
+  # runs them at due time. Flag off means no arming and no immediate fallback — a delayed
+  # message silently becoming instant is worse than skipping.
+  def execute_rule(rule, account, conversation, message: nil)
+    if rule.execution_delay.present?
+      return unless account.feature_enabled?('delayed_automations')
+
+      AutomationRulePendingExecution.schedule(rule: rule, conversation: conversation, message: message)
+    else
+      ::AutomationRules::ActionService.new(rule, account, conversation).perform
     end
   end
 

app/models/account.rb

@@ -65,6 +65,7 @@ class Account < ApplicationRecord
   has_many :articles, dependent: :destroy_async, class_name: '::Article'
   has_many :assignment_policies, dependent: :destroy_async
   has_many :automation_rules, dependent: :destroy_async
+  has_many :automation_rule_pending_executions, dependent: :delete_all
   has_many :macros, dependent: :destroy_async
   has_many :campaigns, dependent: :destroy_async
   has_many :canned_responses, dependent: :destroy_async
@@ -111,6 +112,7 @@ class Account < ApplicationRecord
   before_validation :validate_limit_keys
   after_create_commit :notify_creation
   after_update_commit :clear_unread_conversation_counts_cache, if: :saved_change_to_feature_conversation_unread_counts?
+  after_update_commit :resume_delayed_automations, if: -> { saved_change_to_feature_delayed_automations? && feature_delayed_automations? }
   after_destroy :remove_account_sequences
 
   def agents
@@ -189,6 +191,10 @@ class Account < ApplicationRecord
     ::Conversations::UnreadCounts::Store.clear_account!(id)
   end
 
+  def resume_delayed_automations
+    AutomationRules::ResumePausedExecutionsJob.perform_later(self)
+  end
+
   trigger.after(:insert).for_each(:row) do
     "execute format('create sequence IF NOT EXISTS conv_dpid_seq_%s', NEW.id);"
   end

app/models/automation_rule.rb

@@ -2,16 +2,17 @@
 #
 # Table name: automation_rules
 #
-#  id          :bigint           not null, primary key
-#  actions     :jsonb            not null
-#  active      :boolean          default(TRUE), not null
-#  conditions  :jsonb            not null
-#  description :text
-#  event_name  :string           not null
-#  name        :string           not null
-#  created_at  :datetime         not null
-#  updated_at  :datetime         not null
-#  account_id  :bigint           not null
+#  id              :bigint           not null, primary key
+#  actions         :jsonb            not null
+#  active          :boolean          default(TRUE), not null
+#  conditions      :jsonb            not null
+#  description     :text
+#  event_name      :string           not null
+#  execution_delay :integer
+#  name            :string           not null
+#  created_at      :datetime         not null
+#  updated_at      :datetime         not null
+#  account_id      :bigint           not null
 #
 # Indexes
 #
@@ -21,7 +22,13 @@ class AutomationRule < ApplicationRecord
   include Rails.application.routes.url_helpers
   include Reauthorizable
 
+  EXECUTION_DELAY_RANGE = (10..43_200) # minutes: 10 min to 30 days
+  # Conversation-level delayed rules key their episode on status; only status and attributes
+  # that never change after the delay (inbox) are safe to also filter on.
+  DELAYED_CONVERSATION_ATTRIBUTES = %w[status inbox_id].freeze
+
   belongs_to :account
+  has_many :pending_executions, class_name: 'AutomationRulePendingExecution', dependent: :delete_all
   has_many_attached :files
 
   validate :json_conditions_format
@@ -29,8 +36,13 @@ class AutomationRule < ApplicationRecord
   validate :query_operator_presence
   validate :query_operator_value
   validates :account_id, presence: true
+  validates :execution_delay, numericality: { only_integer: true, in: EXECUTION_DELAY_RANGE }, allow_nil: true
+  validate :execution_delay_supported_conditions
+  validate :execution_delay_supported_event
 
   after_update_commit :reauthorized!, if: -> { saved_change_to_conditions? }
+  # Discard rows armed under the old definition; they re-arm on the next matching event.
+  after_update :discard_stale_pending_executions, if: :execution_config_changed?
 
   scope :active, -> { where(active: true) }
 
@@ -95,6 +107,34 @@ class AutomationRule < ApplicationRecord
     end
   end
 
+  # The fire-time re-check cannot reconstruct changed_attributes, so delayed rules
+  # cannot use attribute_changed conditions.
+  def execution_delay_supported_conditions
+    return if execution_delay.blank? || conditions.blank?
+    return if conditions.none? { |obj| obj['filter_operator'] == 'attribute_changed' }
+
+    errors.add(:execution_delay, 'cannot be used with attribute_changed conditions.')
+  end
+
+  # Conversation-level episodes key on status_changed_at alone. Mutable attributes would collapse
+  # distinct periods into one episode, so only status and immutable filters (inbox) are allowed.
+  def execution_delay_supported_event
+    return if execution_delay.blank? || conditions.blank? || event_name == 'message_created'
+    return if conditions.all? { |obj| DELAYED_CONVERSATION_ATTRIBUTES.include?(obj['attribute_key']) }
+
+    errors.add(:execution_delay, 'only supports status and inbox conditions for conversation-level events.')
+  end
+
+  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
+    # armed = pending + stale processing, which the sweep would otherwise reclaim.
+    pending_executions.armed.delete_all
+  end
+
   def validate_single_condition(condition)
     query_operator = condition['query_operator']
 

app/models/automation_rule_pending_execution.rb

@@ -0,0 +1,180 @@
+# == Schema Information
+#
+# Table name: automation_rule_pending_executions
+#
+#  id                 :bigint           not null, primary key
+#  due_at             :datetime         not null
+#  episode_key        :string           not null
+#  skip_reason        :string
+#  status             :integer          default("pending"), not null
+#  created_at         :datetime         not null
+#  updated_at         :datetime         not null
+#  account_id         :bigint           not null
+#  automation_rule_id :bigint           not null
+#  conversation_id    :bigint           not null
+#  message_id         :bigint
+#
+# Indexes
+#
+#  index_automation_rule_pending_executions_on_account_id          (account_id)
+#  index_automation_rule_pending_executions_on_automation_rule_id  (automation_rule_id)
+#  index_automation_rule_pending_executions_on_conversation_id     (conversation_id)
+#  index_automation_rule_pending_executions_on_status_and_due_at   (status,due_at)
+#  uniq_automation_pending_execution_episode                       (automation_rule_id,conversation_id,episode_key) UNIQUE
+#
+class AutomationRulePendingExecution < ApplicationRecord
+  # Rows older than this never fire (bounds backlog replay after downtime).
+  DUE_WINDOW = 3.days
+  # A processing row whose lock is older than this is treated as abandoned and reclaimed.
+  STALE_PROCESSING_TIMEOUT = 15.minutes
+  # Terminal rows are purged after this to keep the table bounded.
+  RETENTION_WINDOW = 30.days
+  # Skip reason for a row cancelled only because conditions no longer matched at fire time; unlike
+  # other terminal reasons, a later qualifying message can re-arm it (see .schedule).
+  CONDITIONS_CHANGED_SKIP = 'conditions_changed'.freeze
+
+  belongs_to :automation_rule
+  belongs_to :conversation
+  belongs_to :account
+  belongs_to :message, optional: true
+
+  enum status: { pending: 0, processing: 1, executed: 2, skipped: 3 }
+
+  # Rows a sweep should hand to a worker: due pending rows, plus processing rows whose lock went stale.
+  scope :sweepable, lambda {
+    pending.where(due_at: ..Time.current).or(processing.where(updated_at: ...STALE_PROCESSING_TIMEOUT.ago))
+  }
+
+  # Non-terminal rows still bound to fire (a stale processing row is reclaimed by the sweep).
+  scope :armed, -> { where(status: [statuses[:pending], statuses[:processing]]) }
+
+  # Excludes rows whose account paused delayed automations, so one disabled account's backlog
+  # can't fill the sweep limit and starve enabled accounts (paused rows resume on re-enable).
+  scope :for_enabled_accounts, -> { joins(:account).merge(Account.feature_delayed_automations) }
+
+  def self.schedule(rule:, conversation:, message: nil)
+    key = arm_episode_key_for(conversation, message)
+    anchor = arm_anchor_for(conversation, message)
+    create!(
+      automation_rule: rule, conversation: conversation, account_id: conversation.account_id,
+      message_id: message&.id, episode_key: key, due_at: rule.execution_delay.minutes.since(anchor)
+    )
+  rescue ActiveRecord::RecordNotUnique
+    rearm_or_advance_episode(rule, conversation, key, message, anchor)
+  end
+
+  # The episode is already armed. Status episodes keep their first clock (a status change would
+  # give a new key), so only message episodes advance or re-arm here.
+  def self.rearm_or_advance_episode(rule, conversation, key, message, anchor)
+    return unless message
+
+    row = find_by!(automation_rule_id: rule.id, conversation_id: conversation.id, episode_key: key)
+    # Jobs can arrive out of order; only a strictly newer message advances or re-arms, so a late
+    # older message can't pull due_at backwards and fire before the delay elapses.
+    return unless message.id > row.message_id
+
+    due_at = rule.execution_delay.minutes.since(anchor)
+    if row.condition_skipped?
+      # A message episode key can recur (no new incoming reply) while conditions swing back into
+      # match, so a later qualifying message re-arms the condition-only skip instead of dropping.
+      row.update!(status: :pending, skip_reason: nil, due_at: due_at, message_id: message.id)
+    elsif !row.terminal?
+      # Track the newest qualifying message. Reply-chase advances due_at with each agent reply;
+      # awaiting-agent keeps its first clock (its anchor is the stable waiting_since, so due_at is
+      # unchanged). Re-anchoring a row still processing (its worker died mid-run) back to pending
+      # also keeps a stale reclaim from firing the old clock instead of the latest one.
+      row.update!(status: :pending, due_at: due_at, message_id: message.id)
+    end
+  end
+
+  # The wait is measured from when the qualifying event happened, not when this (possibly
+  # backlogged or retried) listener runs, so a late dispatch still fires on schedule. Mirrors
+  # the timestamps the episode keys track.
+  def self.arm_anchor_for(conversation, message)
+    if message.nil?
+      conversation.status_changed_at.presence || conversation.created_at
+    elsif message.incoming?
+      conversation.waiting_since.presence || message.created_at
+    else
+      message.created_at
+    end
+  end
+
+  # waiting_since is written just after MESSAGE_CREATED dispatches, so it can still be nil when
+  # an awaiting-agent episode arms. It becomes the starting message's created_at, so use that
+  # here; the strict fire-time key (episode_key_for) then matches once waiting_since is settled.
+  def self.arm_episode_key_for(conversation, message)
+    return episode_key_for(conversation, message) unless message&.incoming? && conversation.waiting_since.blank?
+
+    "awaiting_agent:#{microsecond_stamp(message.created_at)}"
+  end
+
+  # Microsecond integer, not a float: epoch seconds carry ~16 significant digits, past float64's
+  # precision, so an in-memory timestamp (arm time) and its DB-reloaded value (fire time) would
+  # round to different floats. strftime is exact on both. Sub-second distinguishes rapid episodes.
+  def self.microsecond_stamp(time)
+    time&.strftime('%s%6N') || '0'
+  end
+
+  # Episode keys identify one qualifying stretch of conversation state; when the recomputed
+  # key no longer matches, the episode ended and the pending action is cancelled at fire time.
+  def self.episode_key_for(conversation, message)
+    if message.nil?
+      # Sub-second precision so a resolve→reopen inside one second still ends the episode.
+      # Integer microseconds (not a float) so an in-memory arm and a DB-reloaded fire agree.
+      "status:#{microsecond_stamp(conversation.status_changed_at.presence || conversation.created_at)}"
+    elsif message.incoming?
+      # waiting_since is cleared on agent/bot reply, so a reply invalidates this episode. Strict
+      # here: at fire time a nil waiting_since means the agent replied (episode ended).
+      "awaiting_agent:#{microsecond_stamp(conversation.waiting_since)}"
+    else
+      # A new customer message changes the max incoming id, invalidating this episode.
+      "reply_chase:#{conversation.messages.incoming.maximum(:id) || 0}"
+    end
+  end
+
+  def self.purge_terminal!
+    where(status: [statuses[:executed], statuses[:skipped]], updated_at: ...RETENTION_WINDOW.ago)
+      .in_batches(of: 1000).delete_all
+  end
+
+  # Rows that came due while an account had delayed automations paused would expire the moment
+  # the sweep reaches them on resume. Reset their clock so pause/resume replays them (still
+  # subject to the fire-time episode/condition re-checks) instead of silently dropping them.
+  def self.reschedule_paused(account)
+    overdue = pending.where(account_id: account.id, due_at: ...DUE_WINDOW.ago)
+    overdue.find_each { |row| row.update!(due_at: Time.current) }
+  end
+
+  # Atomic claim: only one worker can move a row into processing, so a row re-enqueued by an
+  # overlapping sweep (or after a stale reclaim) cannot double-execute. Refreshing updated_at
+  # renews the lock, keeping the row out of the stale window while this worker holds it.
+  def claim!
+    with_lock do
+      next false unless claimable?
+
+      update!(status: :processing, updated_at: Time.current)
+      true
+    end
+  end
+
+  def episode_current?
+    self.class.episode_key_for(conversation, message) == episode_key
+  end
+
+  def condition_skipped?
+    skipped? && skip_reason == CONDITIONS_CHANGED_SKIP
+  end
+
+  def terminal?
+    executed? || skipped?
+  end
+
+  private
+
+  def claimable?
+    # due_at guard: a reply-chase reschedule can push due_at forward after this row was enqueued;
+    # such a row must wait for a later sweep instead of firing early.
+    (pending? && due_at <= Time.current) || (processing? && updated_at < STALE_PROCESSING_TIMEOUT.ago)
+  end
+end

app/models/conversation.rb

@@ -15,6 +15,7 @@
 #  priority               :integer
 #  snoozed_until          :datetime
 #  status                 :integer          default("open"), not null
+#  status_changed_at      :datetime
 #  uuid                   :uuid             not null
 #  waiting_since          :datetime
 #  created_at             :datetime         not null
@@ -124,8 +125,10 @@ class Conversation < ApplicationRecord
   has_many :notifications, as: :primary_actor, dependent: :destroy_async
   has_many :attachments, through: :messages
   has_many :reporting_events, dependent: :destroy_async
+  has_many :automation_rule_pending_executions, dependent: :delete_all
 
   before_save :ensure_snooze_until_reset
+  before_save :set_status_changed_at
   before_create :determine_conversation_status
   before_create :ensure_waiting_since
 
@@ -272,6 +275,10 @@ class Conversation < ApplicationRecord
     self.snoozed_until = nil unless snoozed?
   end
 
+  def set_status_changed_at
+    self.status_changed_at = Time.current if new_record? || status_changed?
+  end
+
   def ensure_waiting_since
     self.waiting_since = created_at
   end

app/views/api/v1/accounts/automation_rules/partials/_automation_rule.json.jbuilder

@@ -7,4 +7,5 @@ json.conditions automation_rule.conditions
 json.actions automation_rule.actions
 json.created_on automation_rule.created_at.to_i
 json.active automation_rule.active?
+json.execution_delay automation_rule.execution_delay
 json.files automation_rule.file_base_data if automation_rule.files.any?

config/features.yml

@@ -268,3 +268,8 @@
   display_name: WhatsApp Embedded Signup Flow
   enabled: false
   column: feature_flags_ext_1
+- name: delayed_automations
+  display_name: Delayed Automations
+  enabled: false
+  chatwoot_internal: true
+  column: feature_flags_ext_1

config/installation_config.yml

@@ -567,3 +567,10 @@
   value: 'https://us.cloud.langfuse.com'
   locked: false
 ## ---- End of LLM Observability ---- ##
+
+- name: DISABLE_DELAYED_AUTOMATIONS
+  display_title: 'Disable delayed automations'
+  description: 'Emergency stop for delayed automation rules: halts the pending-execution sweep and per-row execution within one tick'
+  value: false
+  locked: false
+  type: boolean

db/migrate/20260709060000_add_execution_delay_to_automation_rules.rb

@@ -0,0 +1,5 @@
+class AddExecutionDelayToAutomationRules < ActiveRecord::Migration[7.0]
+  def change
+    add_column :automation_rules, :execution_delay, :integer
+  end
+end

db/migrate/20260709060100_add_status_changed_at_to_conversations.rb

@@ -0,0 +1,5 @@
+class AddStatusChangedAtToConversations < ActiveRecord::Migration[7.0]
+  def change
+    add_column :conversations, :status_changed_at, :datetime
+  end
+end

db/migrate/20260709060200_create_automation_rule_pending_executions.rb

@@ -0,0 +1,21 @@
+class CreateAutomationRulePendingExecutions < ActiveRecord::Migration[7.0]
+  def change
+    create_table :automation_rule_pending_executions do |t|
+      t.references :automation_rule, null: false
+      t.references :conversation, null: false
+      t.references :account, null: false
+      t.bigint :message_id
+      t.datetime :due_at, null: false
+      t.string :episode_key, null: false
+      t.integer :status, null: false, default: 0
+      t.string :skip_reason
+
+      t.timestamps
+    end
+
+    add_index :automation_rule_pending_executions, [:status, :due_at]
+    add_index :automation_rule_pending_executions,
+              [:automation_rule_id, :conversation_id, :episode_key],
+              unique: true, name: 'uniq_automation_pending_execution_episode'
+  end
+end

db/schema.rb

@@ -277,6 +277,24 @@ ActiveRecord::Schema[7.1].define(version: 2026_07_13_184351) do
     t.index ["user_id", "user_type"], name: "user_index"
   end
 
+  create_table "automation_rule_pending_executions", force: :cascade do |t|
+    t.bigint "automation_rule_id", null: false
+    t.bigint "conversation_id", null: false
+    t.bigint "account_id", null: false
+    t.bigint "message_id"
+    t.datetime "due_at", null: false
+    t.string "episode_key", null: false
+    t.integer "status", default: 0, null: false
+    t.string "skip_reason"
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
+    t.index ["account_id"], name: "index_automation_rule_pending_executions_on_account_id"
+    t.index ["automation_rule_id", "conversation_id", "episode_key"], name: "uniq_automation_pending_execution_episode", unique: true
+    t.index ["automation_rule_id"], name: "index_automation_rule_pending_executions_on_automation_rule_id"
+    t.index ["conversation_id"], name: "index_automation_rule_pending_executions_on_conversation_id"
+    t.index ["status", "due_at"], name: "index_automation_rule_pending_executions_on_status_and_due_at"
+  end
+
   create_table "automation_rules", force: :cascade do |t|
     t.bigint "account_id", null: false
     t.string "name", null: false
@@ -287,6 +305,7 @@ ActiveRecord::Schema[7.1].define(version: 2026_07_13_184351) do
     t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
     t.boolean "active", default: true, null: false
+    t.integer "execution_delay"
     t.index ["account_id"], name: "index_automation_rules_on_account_id"
   end
 
@@ -788,6 +807,7 @@ ActiveRecord::Schema[7.1].define(version: 2026_07_13_184351) do
     t.datetime "waiting_since"
     t.text "cached_label_list"
     t.bigint "assignee_agent_bot_id"
+    t.datetime "status_changed_at"
     t.index ["account_id", "display_id"], name: "index_conversations_on_account_id_and_display_id", unique: true
     t.index ["account_id", "id"], name: "index_conversations_on_id_and_account_id"
     t.index ["account_id", "inbox_id", "status", "assignee_id"], name: "conv_acid_inbid_stat_asgnid_idx"

spec/controllers/api/v1/accounts/automation_rules_controller_spec.rb

@@ -451,4 +451,71 @@ RSpec.describe 'Api::V1::Accounts::AutomationRulesController', type: :request do
       end
     end
   end
+
+  describe 'execution_delay handling' do
+    let(:delayed_rule_params) do
+      {
+        name: 'Delayed rule',
+        event_name: 'conversation_updated',
+        execution_delay: 240,
+        conditions: [{ attribute_key: 'status', filter_operator: 'equal_to', values: ['pending'], query_operator: nil }],
+        actions: [{ action_name: 'add_label', action_params: ['stale'] }]
+      }
+    end
+
+    context 'when the delayed_automations feature is enabled' do
+      before { account.enable_features!('delayed_automations') }
+
+      it 'persists and serializes execution_delay' do
+        post "/api/v1/accounts/#{account.id}/automation_rules",
+             headers: administrator.create_new_auth_token,
+             params: delayed_rule_params
+
+        expect(response).to have_http_status(:success)
+        body = JSON.parse(response.body, symbolize_names: true)
+        expect(body[:execution_delay]).to eq(240)
+        expect(account.automation_rules.last.execution_delay).to eq(240)
+      end
+
+      it 'copies execution_delay on clone' do
+        automation_rule = create(:automation_rule, account: account, execution_delay: 240)
+
+        post "/api/v1/accounts/#{account.id}/automation_rules/#{automation_rule.id}/clone",
+             headers: administrator.create_new_auth_token
+
+        expect(response).to have_http_status(:success)
+        expect(account.automation_rules.last.execution_delay).to eq(240)
+      end
+    end
+
+    context 'when the delayed_automations feature is disabled' do
+      it 'rejects a payload carrying execution_delay with 422' do
+        post "/api/v1/accounts/#{account.id}/automation_rules",
+             headers: administrator.create_new_auth_token,
+             params: delayed_rule_params
+
+        expect(response).to have_http_status(:unprocessable_entity)
+        expect(account.automation_rules.count).to eq(0)
+      end
+
+      it 'still accepts payloads without execution_delay' do
+        post "/api/v1/accounts/#{account.id}/automation_rules",
+             headers: administrator.create_new_auth_token,
+             params: delayed_rule_params.except(:execution_delay)
+
+        expect(response).to have_http_status(:success)
+        expect(account.automation_rules.last.execution_delay).to be_nil
+      end
+
+      it 'strips execution_delay when cloning an existing delayed rule' do
+        automation_rule = create(:automation_rule, account: account, execution_delay: 240)
+
+        post "/api/v1/accounts/#{account.id}/automation_rules/#{automation_rule.id}/clone",
+             headers: administrator.create_new_auth_token
+
+        expect(response).to have_http_status(:success)
+        expect(account.automation_rules.last.execution_delay).to be_nil
+      end
+    end
+  end
 end

spec/factories/automation_rule_pending_executions.rb

@@ -0,0 +1,11 @@
+FactoryBot.define do
+  factory :automation_rule_pending_execution do
+    account
+    automation_rule { association :automation_rule, account: account }
+    conversation { association :conversation, account: account }
+    # Derive from production so the row is episode_current (matches the conversation's status).
+    episode_key { AutomationRulePendingExecution.episode_key_for(conversation, nil) }
+    due_at { 1.hour.from_now }
+    status { :pending }
+  end
+end

spec/jobs/automation_rules/process_pending_execution_job_spec.rb

@@ -0,0 +1,155 @@
+require 'rails_helper'
+
+RSpec.describe AutomationRules::ProcessPendingExecutionJob do
+  subject(:job) { described_class.new }
+
+  let(:account) { create(:account) }
+  let(:conversation) { create(:conversation, account: account, status: :pending) }
+  let(:rule) do
+    create(:automation_rule, account: account, event_name: 'conversation_updated', execution_delay: 60,
+                             conditions: [{ 'values' => ['pending'], 'attribute_key' => 'status', 'query_operator' => nil,
+                                            'filter_operator' => 'equal_to' }],
+                             actions: [{ 'action_name' => 'add_label', 'action_params' => ['stale'] }])
+  end
+  let(:pending_execution) do
+    AutomationRulePendingExecution.schedule(rule: rule, conversation: conversation)
+    # The sweep only enqueues due rows, so make it due before the job runs.
+    AutomationRulePendingExecution.last.tap { |row| row.update!(due_at: 1.minute.ago) }
+  end
+
+  before do
+    GlobalConfig.clear_cache
+    account.enable_features!('delayed_automations')
+  end
+
+  it 'runs the actions and marks the row executed when every guard passes' do
+    job.perform(pending_execution.reload)
+
+    expect(pending_execution.reload).to be_executed
+    expect(conversation.reload.label_list).to include('stale')
+  end
+
+  it 'skips with rule_inactive when the rule was disabled' do
+    rule.update!(active: false)
+    job.perform(pending_execution.reload)
+
+    expect(pending_execution.reload).to be_skipped
+    expect(pending_execution.skip_reason).to eq('rule_inactive')
+    expect(conversation.reload.label_list).to be_empty
+  end
+
+  it 'pauses (keeps pending) while the account flag is off, then fires when re-enabled' do
+    account.disable_features!('delayed_automations')
+    job.perform(pending_execution.reload)
+
+    expect(pending_execution.reload).to be_pending
+    expect(conversation.reload.label_list).to be_empty
+
+    account.enable_features!('delayed_automations')
+    described_class.new.perform(pending_execution.reload)
+
+    expect(pending_execution.reload).to be_executed
+    expect(conversation.reload.label_list).to include('stale')
+  end
+
+  it 'skips with episode_moved when the conversation left the armed status' do
+    pending_execution
+    conversation.update!(status: :resolved)
+    job.perform(pending_execution.reload)
+
+    expect(pending_execution.reload).to be_skipped
+    expect(pending_execution.skip_reason).to eq('episode_moved')
+    expect(conversation.reload.label_list).to be_empty
+  end
+
+  it 'skips with conditions_changed when the conversation drifts but the episode is intact' do
+    # A message_created (reply-chase) rule whose extra condition is the conversation status.
+    message_rule = create(:automation_rule, account: account, event_name: 'message_created', execution_delay: 60,
+                                            conditions: [{ 'values' => ['pending'], 'attribute_key' => 'status',
+                                                           'query_operator' => nil, 'filter_operator' => 'equal_to' }],
+                                            actions: [{ 'action_name' => 'add_label', 'action_params' => ['stale'] }])
+    agent_reply = create(:message, conversation: conversation, account: account, message_type: :outgoing)
+    AutomationRulePendingExecution.schedule(rule: message_rule, conversation: conversation, message: agent_reply)
+    row = AutomationRulePendingExecution.last.tap { |r| r.update!(due_at: 1.minute.ago) }
+
+    # Status change fails the condition but leaves the reply_chase episode (max incoming id) intact.
+    conversation.update!(status: :open)
+    job.perform(row)
+
+    expect(row.reload).to be_skipped
+    expect(row.skip_reason).to eq('conditions_changed')
+  end
+
+  it 'skips with expired when the row is past the due window' do
+    pending_execution.update!(due_at: 4.days.ago)
+    job.perform(pending_execution.reload)
+
+    expect(pending_execution.reload).to be_skipped
+    expect(pending_execution.skip_reason).to eq('expired')
+    expect(conversation.reload.label_list).to be_empty
+  end
+
+  it 'leaves the row untouched without executing when the kill switch is set' do
+    create(:installation_config, name: 'DISABLE_DELAYED_AUTOMATIONS', serialized_value: { value: true }.with_indifferent_access)
+    GlobalConfig.clear_cache
+    job.perform(pending_execution.reload)
+
+    expect(pending_execution.reload).to be_pending
+    expect(conversation.reload.label_list).to be_empty
+  end
+
+  it 'runs the actions once when the same row is processed twice concurrently' do
+    allow(AutomationRules::ActionService).to receive(:new).and_call_original
+    duplicate = AutomationRulePendingExecution.find(pending_execution.id)
+
+    job.perform(pending_execution.reload)
+    described_class.new.perform(duplicate)
+
+    expect(AutomationRules::ActionService).to have_received(:new).once
+    expect(pending_execution.reload).to be_executed
+  end
+
+  it 'leaves the row processing and reports the error when an action blows up' do
+    action_service = instance_double(AutomationRules::ActionService)
+    allow(AutomationRules::ActionService).to receive(:new).and_return(action_service)
+    allow(action_service).to receive(:perform).and_raise(StandardError, 'boom')
+    allow(ChatwootExceptionTracker).to receive(:new).and_call_original
+
+    job.perform(pending_execution.reload)
+
+    expect(pending_execution.reload).to be_processing
+    expect(ChatwootExceptionTracker).to have_received(:new)
+  end
+
+  it 'sends the follow-up exactly once for the reply-chase story' do
+    message_rule = create(:automation_rule, account: account, event_name: 'message_created', execution_delay: 60,
+                                            conditions: [{ 'values' => ['outgoing'], 'attribute_key' => 'message_type',
+                                                           'query_operator' => nil, 'filter_operator' => 'equal_to' }],
+                                            actions: [{ 'action_name' => 'send_message', 'action_params' => ['Just checking in'] }])
+    agent_reply = create(:message, conversation: conversation, account: account, message_type: :outgoing)
+    AutomationRulePendingExecution.schedule(rule: message_rule, conversation: conversation, message: agent_reply)
+    row = AutomationRulePendingExecution.last.tap { |r| r.update!(due_at: 1.minute.ago) }
+
+    job.perform(row.reload)
+
+    expect(row.reload).to be_executed
+    expect(conversation.messages.outgoing.where(content: 'Just checking in').count).to eq(1)
+  end
+
+  it 'cancels the follow-up when the customer replied before it was due' do
+    message_rule = create(:automation_rule, account: account, event_name: 'message_created', execution_delay: 60,
+                                            conditions: [{ 'values' => ['outgoing'], 'attribute_key' => 'message_type',
+                                                           'query_operator' => nil, 'filter_operator' => 'equal_to' }],
+                                            actions: [{ 'action_name' => 'send_message', 'action_params' => ['Just checking in'] }])
+    agent_reply = create(:message, conversation: conversation, account: account, message_type: :outgoing)
+    AutomationRulePendingExecution.schedule(rule: message_rule, conversation: conversation, message: agent_reply)
+    row = AutomationRulePendingExecution.last.tap { |r| r.update!(due_at: 1.minute.ago) }
+
+    create(:message, conversation: conversation, account: account, message_type: :incoming)
+    job.perform(row.reload)
+
+    expect(row.reload).to be_skipped
+    expect(row.skip_reason).to eq('episode_moved')
+    expect(conversation.messages.outgoing.pluck(:content)).not_to include('Just checking in')
+  end
+end

spec/jobs/automation_rules/trigger_pending_executions_job_spec.rb

@@ -0,0 +1,62 @@
+require 'rails_helper'
+
+RSpec.describe AutomationRules::TriggerPendingExecutionsJob do
+  subject(:job) { described_class.new }
+
+  let(:account) { create(:account) }
+  let(:conversation) { create(:conversation, account: account) }
+
+  before do
+    GlobalConfig.clear_cache
+    account.enable_features!('delayed_automations')
+  end
+
+  it 'enqueues a per-row job for due pending rows but not future ones' do
+    due_row = create(:automation_rule_pending_execution, account: account, conversation: conversation, due_at: 1.minute.ago)
+    future_row = create(:automation_rule_pending_execution, account: account, due_at: 1.hour.from_now)
+
+    expect { job.perform }.to have_enqueued_job(AutomationRules::ProcessPendingExecutionJob).exactly(:once)
+    expect(AutomationRules::ProcessPendingExecutionJob).to have_been_enqueued.with(due_row)
+    expect(AutomationRules::ProcessPendingExecutionJob).not_to have_been_enqueued.with(future_row)
+  end
+
+  it 're-enqueues stale processing rows so they get retried' do
+    stale_row = travel_to(20.minutes.ago) do
+      create(:automation_rule_pending_execution, account: account, conversation: conversation, status: :processing, due_at: 19.minutes.from_now)
+    end
+
+    expect { job.perform }.to have_enqueued_job(AutomationRules::ProcessPendingExecutionJob).with(stale_row)
+  end
+
+  it 'caps enqueues at the configured sweep limit' do
+    create(:installation_config, name: 'AUTOMATION_PENDING_EXECUTIONS_SWEEP_LIMIT', serialized_value: { value: 1 }.with_indifferent_access)
+    create_list(:automation_rule_pending_execution, 2, account: account, due_at: 1.minute.ago)
+
+    expect { job.perform }.to have_enqueued_job(AutomationRules::ProcessPendingExecutionJob).exactly(:once)
+  end
+
+  it 'purges terminal rows past the retention window' do
+    old_row = travel_to(31.days.ago) { create(:automation_rule_pending_execution, account: account, status: :executed) }
+
+    job.perform
+
+    expect { old_row.reload }.to raise_error(ActiveRecord::RecordNotFound)
+  end
+
+  it 'skips rows for accounts with delayed automations disabled so they cannot starve others' do
+    enabled_row = create(:automation_rule_pending_execution, account: account, conversation: conversation, due_at: 1.minute.ago)
+    disabled_account = create(:account) # delayed_automations off by default
+    create(:automation_rule_pending_execution, account: disabled_account, due_at: 2.minutes.ago)
+
+    expect { job.perform }.to have_enqueued_job(AutomationRules::ProcessPendingExecutionJob).exactly(:once)
+    expect(AutomationRules::ProcessPendingExecutionJob).to have_been_enqueued.with(enabled_row)
+  end
+
+  it 'does nothing when the kill switch is set' do
+    create(:installation_config, name: 'DISABLE_DELAYED_AUTOMATIONS', serialized_value: { value: true }.with_indifferent_access)
+    GlobalConfig.clear_cache
+    create(:automation_rule_pending_execution, account: account, conversation: conversation, due_at: 1.minute.ago)
+
+    expect { job.perform }.not_to have_enqueued_job(AutomationRules::ProcessPendingExecutionJob)
+  end
+end

spec/listeners/automation_rule_listener_spec.rb

@@ -247,4 +247,37 @@ describe AutomationRuleListener do
       end
     end
   end
+
+  describe 'delayed rules' do
+    let!(:automation_rule) { create(:automation_rule, event_name: 'conversation_updated', account: account, execution_delay: 60) }
+    let(:event) do
+      Events::Base.new('conversation_updated', Time.zone.now, { conversation: conversation, changed_attributes: {} })
+    end
+
+    before { allow(condition_match).to receive(:present?).and_return(true) }
+
+    context 'when the delayed_automations feature is enabled' do
+      before { account.enable_features!('delayed_automations') }
+
+      it 'records a pending execution instead of running actions' do
+        expect { listener.conversation_updated(event) }.to change(AutomationRulePendingExecution, :count).by(1)
+        expect(AutomationRules::ActionService).not_to have_received(:new)
+        expect(AutomationRulePendingExecution.last.due_at).to be_within(5.seconds).of(60.minutes.from_now)
+      end
+
+      it 'still runs rules without a delay immediately' do
+        automation_rule.update!(execution_delay: nil)
+
+        expect { listener.conversation_updated(event) }.not_to change(AutomationRulePendingExecution, :count)
+        expect(AutomationRules::ActionService).to have_received(:new).with(automation_rule, account, conversation)
+      end
+    end
+
+    context 'when the delayed_automations feature is disabled' do
+      it 'neither arms a pending execution nor falls back to immediate execution' do
+        expect { listener.conversation_updated(event) }.not_to change(AutomationRulePendingExecution, :count)
+        expect(AutomationRules::ActionService).not_to have_received(:new)
+      end
+    end
+  end
 end

spec/models/account_spec.rb

@@ -112,6 +112,21 @@ RSpec.describe Account do
     end
   end
 
+  describe 'resuming delayed automations' do
+    let(:account) { create(:account) }
+
+    it 'enqueues the resume job when delayed_automations is turned back on' do
+      expect { account.enable_features!('delayed_automations') }
+        .to have_enqueued_job(AutomationRules::ResumePausedExecutionsJob).with(account)
+    end
+
+    it 'does not enqueue the resume job when the flag is turned off' do
+      account.enable_features!('delayed_automations')
+      expect { account.disable_features!('delayed_automations') }
+        .not_to have_enqueued_job(AutomationRules::ResumePausedExecutionsJob)
+    end
+  end
+
   describe 'feature flag columns' do
     let(:account) { described_class.new(name: 'Test Account') }
 
@@ -122,7 +137,8 @@ RSpec.describe Account do
         feature_data_import: 1 << 1,
         feature_api_and_webhooks: 1 << 2,
         feature_whatsapp_reconfigure: 1 << 3,
-        feature_whatsapp_embedded_signup_inbox_creation: 1 << 4
+        feature_whatsapp_embedded_signup_inbox_creation: 1 << 4,
+        feature_delayed_automations: 1 << 5
       )
       expect(described_class.flag_mapping['feature_flags_ext_1'][:feature_whatsapp_manual_transfer]).to eq(1)
       expect(described_class.flag_mapping['feature_flags_ext_1'][:feature_data_import]).to eq(2)

spec/models/automation_rule_pending_execution_spec.rb

@@ -0,0 +1,305 @@
+require 'rails_helper'
+
+RSpec.describe AutomationRulePendingExecution do
+  let(:account) { create(:account) }
+  let(:conversation) { create(:conversation, account: account) }
+  let(:rule) do
+    create(:automation_rule, account: account, event_name: 'conversation_updated', execution_delay: 60,
+                             actions: [{ 'action_name' => 'add_label', 'action_params' => ['stale'] }])
+  end
+
+  describe '.episode_key_for' do
+    it 'derives status episodes from status_changed_at' do
+      expect(described_class.episode_key_for(conversation, nil)).to eq("status:#{conversation.status_changed_at.strftime('%s%6N')}")
+    end
+
+    it 'matches between an in-memory arm and a DB-reloaded fire (no float rounding drift)' do
+      conversation.status_changed_at = Time.zone.at(1_784_102_080.844761923r)
+      arm_key = described_class.episode_key_for(conversation, nil)
+      conversation.save!
+      expect(arm_key).to eq(described_class.episode_key_for(conversation.reload, nil))
+    end
+
+    it 'falls back to created_at when status_changed_at is blank' do
+      conversation.update!(status_changed_at: nil)
+      expect(described_class.episode_key_for(conversation.reload, nil)).to eq("status:#{conversation.created_at.strftime('%s%6N')}")
+    end
+
+    it 'derives awaiting_agent episodes from waiting_since (sub-second) for incoming messages' do
+      message = create(:message, conversation: conversation, account: account, message_type: :incoming)
+      expect(described_class.episode_key_for(conversation.reload, message)).to eq("awaiting_agent:#{conversation.waiting_since.strftime('%s%6N')}")
+    end
+
+    it 'distinguishes two waiting periods that fall within the same second' do
+      message = create(:message, conversation: conversation, account: account, message_type: :incoming)
+      first_key = described_class.episode_key_for(conversation.reload, message)
+
+      # Agent replies then customer re-waits within the same second: keys must differ.
+      conversation.update!(waiting_since: conversation.waiting_since + 0.4)
+      expect(described_class.episode_key_for(conversation.reload, message)).not_to eq(first_key)
+    end
+
+    it 'arms an awaiting_agent episode from the message created_at when waiting_since is not yet written' do
+      message = create(:message, conversation: conversation, account: account, message_type: :incoming)
+      # Simulate the race where the listener arms before update_waiting_since commits.
+      conversation.update!(waiting_since: nil)
+      armed_key = described_class.arm_episode_key_for(conversation.reload, message)
+
+      # Once waiting_since settles to the message's created_at, the strict fire-time key matches.
+      conversation.update!(waiting_since: message.created_at)
+      expect(armed_key).to eq("awaiting_agent:#{message.created_at.strftime('%s%6N')}")
+      expect(armed_key).to eq(described_class.episode_key_for(conversation.reload, message))
+    end
+
+    it 'derives reply_chase episodes from the max incoming message id for outgoing messages' do
+      incoming = create(:message, conversation: conversation, account: account, message_type: :incoming)
+      outgoing = create(:message, conversation: conversation, account: account, message_type: :outgoing)
+      expect(described_class.episode_key_for(conversation.reload, outgoing)).to eq("reply_chase:#{incoming.id}")
+    end
+
+    it 'uses 0 for reply_chase when there is no incoming message' do
+      outgoing = create(:message, conversation: conversation, account: account, message_type: :outgoing)
+      expect(described_class.episode_key_for(conversation.reload, outgoing)).to eq('reply_chase:0')
+    end
+  end
+
+  describe '.schedule' do
+    it 'creates a pending row due after the rule delay' do
+      described_class.schedule(rule: rule, conversation: conversation)
+
+      row = described_class.last
+      expect(row).to have_attributes(account_id: account.id, conversation_id: conversation.id, status: 'pending')
+      expect(row.due_at).to be_within(5.seconds).of(60.minutes.from_now)
+    end
+
+    it 'anchors due_at to the event time, not when a backlogged listener runs' do
+      conversation.update!(status_changed_at: 30.minutes.ago)
+      described_class.schedule(rule: rule, conversation: conversation)
+
+      # A 60-minute rule on a status that changed 30 minutes ago is already 30 minutes into its wait.
+      expect(described_class.last.due_at).to be_within(5.seconds).of(30.minutes.from_now)
+    end
+
+    it 'does not reset the clock for a repeated status episode' do
+      described_class.schedule(rule: rule, conversation: conversation)
+      original_due_at = described_class.last.due_at
+
+      travel_to(30.minutes.from_now) { described_class.schedule(rule: rule, conversation: conversation) }
+
+      expect(described_class.count).to eq(1)
+      expect(described_class.last.due_at).to be_within(1.second).of(original_due_at)
+    end
+
+    it 'moves the clock and anchor for a repeated reply_chase episode' do
+      first_reply = create(:message, conversation: conversation, account: account, message_type: :outgoing)
+      described_class.schedule(rule: rule, conversation: conversation, message: first_reply)
+
+      travel_to(30.minutes.from_now) do
+        second_reply = create(:message, conversation: conversation, account: account, message_type: :outgoing)
+        described_class.schedule(rule: rule, conversation: conversation, message: second_reply)
+
+        # due_at is re-anchored to the new reply's created_at, not the original schedule time.
+        expect(described_class.count).to eq(1)
+        expect(described_class.last.message_id).to eq(second_reply.id)
+        expect(described_class.last.due_at).to be_within(5.seconds).of(60.minutes.from_now)
+      end
+    end
+
+    it 'does not let a late older reply move the reply_chase clock backwards' do
+      older_reply = create(:message, conversation: conversation, account: account, message_type: :outgoing)
+      newer_reply = create(:message, conversation: conversation, account: account, message_type: :outgoing)
+
+      # The newer reply's job runs first and arms the episode.
+      described_class.schedule(rule: rule, conversation: conversation, message: newer_reply)
+      armed_due_at = described_class.last.due_at
+
+      # The older reply's job arrives late; it must not pull the clock or message_id back.
+      described_class.schedule(rule: rule, conversation: conversation, message: older_reply)
+
+      expect(described_class.count).to eq(1)
+      expect(described_class.last.message_id).to eq(newer_reply.id)
+      expect(described_class.last.due_at).to eq(armed_due_at)
+    end
+
+    it 'does not re-arm an executed reply_chase episode' do
+      reply = create(:message, conversation: conversation, account: account, message_type: :outgoing)
+      described_class.schedule(rule: rule, conversation: conversation, message: reply)
+      described_class.last.update!(status: :executed)
+
+      described_class.schedule(rule: rule, conversation: conversation, message: reply)
+
+      expect(described_class.count).to eq(1)
+      expect(described_class.last).to be_executed
+    end
+
+    it 're-arms a condition-skipped episode when a newer qualifying message arrives' do
+      first_reply = create(:message, conversation: conversation, account: account, message_type: :outgoing)
+      described_class.schedule(rule: rule, conversation: conversation, message: first_reply)
+      described_class.last.update!(status: :skipped, skip_reason: 'conditions_changed')
+
+      second_reply = create(:message, conversation: conversation, account: account, message_type: :outgoing)
+      described_class.schedule(rule: rule, conversation: conversation, message: second_reply)
+
+      row = described_class.last
+      expect(described_class.count).to eq(1)
+      expect(row).to be_pending
+      expect(row.skip_reason).to be_nil
+      expect(row.message_id).to eq(second_reply.id)
+    end
+
+    it 're-anchors a reply_chase row stuck in processing when a newer reply arrives' do
+      first_reply = create(:message, conversation: conversation, account: account, message_type: :outgoing)
+      described_class.schedule(rule: rule, conversation: conversation, message: first_reply)
+      # The worker claimed the row and then died, leaving it in processing with the old clock.
+      described_class.last.update!(status: :processing)
+
+      travel_to(30.minutes.from_now) do
+        second_reply = create(:message, conversation: conversation, account: account, message_type: :outgoing)
+        described_class.schedule(rule: rule, conversation: conversation, message: second_reply)
+
+        row = described_class.last
+        expect(described_class.count).to eq(1)
+        expect(row).to be_pending
+        expect(row.message_id).to eq(second_reply.id)
+        expect(row.due_at).to be_within(5.seconds).of(60.minutes.from_now)
+      end
+    end
+
+    it 'does not re-arm an episode skipped for a non-condition reason' do
+      reply = create(:message, conversation: conversation, account: account, message_type: :outgoing)
+      described_class.schedule(rule: rule, conversation: conversation, message: reply)
+      described_class.last.update!(status: :skipped, skip_reason: 'episode_moved')
+
+      newer_reply = create(:message, conversation: conversation, account: account, message_type: :outgoing)
+      described_class.schedule(rule: rule, conversation: conversation, message: newer_reply)
+
+      expect(described_class.count).to eq(1)
+      expect(described_class.last).to be_skipped
+    end
+
+    it 'keeps the awaiting_agent clock but tracks the newest incoming message' do
+      first_message = create(:message, conversation: conversation, account: account, message_type: :incoming)
+      described_class.schedule(rule: rule, conversation: conversation, message: first_message)
+      original_due_at = described_class.last.due_at
+
+      second_message = create(:message, conversation: conversation, account: account, message_type: :incoming)
+      travel_to(30.minutes.from_now) { described_class.schedule(rule: rule, conversation: conversation, message: second_message) }
+
+      row = described_class.last
+      expect(described_class.count).to eq(1)
+      # The wait still counts from waiting_since, so the clock is unchanged...
+      expect(row.due_at).to be_within(1.second).of(original_due_at)
+      # ...but the row tracks the newest qualifying message, not the stale first one.
+      expect(row.message_id).to eq(second_message.id)
+    end
+
+    it 'keeps the newest message when an older incoming collision arrives last' do
+      first_message = create(:message, conversation: conversation, account: account, message_type: :incoming)
+      described_class.schedule(rule: rule, conversation: conversation, message: first_message)
+
+      older = create(:message, conversation: conversation, account: account, message_type: :incoming)
+      newer = create(:message, conversation: conversation, account: account, message_type: :incoming)
+
+      # The newer message re-arms first; a late older-message collision must not overwrite it.
+      described_class.schedule(rule: rule, conversation: conversation, message: newer)
+      described_class.schedule(rule: rule, conversation: conversation, message: older)
+
+      expect(described_class.count).to eq(1)
+      expect(described_class.last.message_id).to eq(newer.id)
+    end
+  end
+
+  describe '#episode_current?' do
+    it 'is true while the conversation stays in the armed status' do
+      described_class.schedule(rule: rule, conversation: conversation)
+      expect(described_class.last.episode_current?).to be(true)
+    end
+
+    it 'is false after a status transition' do
+      described_class.schedule(rule: rule, conversation: conversation)
+      conversation.update!(status: :resolved)
+      expect(described_class.last.reload.episode_current?).to be(false)
+    end
+
+    it 'is false for awaiting_agent episodes once the agent replies (waiting_since cleared)' do
+      message = create(:message, conversation: conversation, account: account, message_type: :incoming)
+      described_class.schedule(rule: rule, conversation: conversation, message: message)
+
+      conversation.update!(waiting_since: nil)
+      expect(described_class.last.episode_current?).to be(false)
+    end
+
+    it 'is false for reply_chase episodes once the customer replies' do
+      reply = create(:message, conversation: conversation, account: account, message_type: :outgoing)
+      described_class.schedule(rule: rule, conversation: conversation, message: reply)
+
+      create(:message, conversation: conversation, account: account, message_type: :incoming)
+      expect(described_class.last.episode_current?).to be(false)
+    end
+  end
+
+  describe '#claim!' do
+    let(:row) { create(:automation_rule_pending_execution, account: account, conversation: conversation, due_at: 1.minute.ago) }
+
+    it 'claims a pending row exactly once so a duplicate enqueue cannot double-fire' do
+      expect(row.claim!).to be(true)
+      expect(row.reload).to be_processing
+      expect(described_class.find(row.id).claim!).to be(false)
+    end
+
+    it 'does not claim a row whose due_at was pushed into the future (reply-chase reschedule)' do
+      row.update!(due_at: 1.hour.from_now)
+      expect(row.claim!).to be(false)
+    end
+
+    it 'does not claim terminal rows' do
+      row.update!(status: :executed)
+      expect(row.claim!).to be(false)
+    end
+
+    it 'reclaims a processing row only after its lock goes stale' do
+      row.update!(status: :processing)
+      expect(row.claim!).to be(false)
+
+      travel_to(20.minutes.from_now) { expect(row.claim!).to be(true) }
+    end
+  end
+
+  describe '.sweepable' do
+    it 'selects due pending rows and stale processing rows, but not future or fresh ones' do
+      due = create(:automation_rule_pending_execution, account: account, conversation: conversation, due_at: 1.minute.ago)
+      create(:automation_rule_pending_execution, account: account, due_at: 1.hour.from_now)
+      create(:automation_rule_pending_execution, account: account, status: :processing)
+      stale = travel_to(20.minutes.ago) do
+        create(:automation_rule_pending_execution, account: account, conversation: conversation, status: :processing)
+      end
+
+      expect(described_class.sweepable).to contain_exactly(due, stale)
+    end
+  end
+
+  describe '.purge_terminal!' do
+    it 'deletes terminal rows past the retention window and keeps everything else' do
+      old_executed = travel_to(31.days.ago) { create(:automation_rule_pending_execution, account: account, status: :executed) }
+      recent_skipped = create(:automation_rule_pending_execution, account: account, status: :skipped)
+      pending = create(:automation_rule_pending_execution, account: account, conversation: conversation)
+
+      described_class.purge_terminal!
+
+      expect(described_class.pluck(:id)).to contain_exactly(recent_skipped.id, pending.id)
+      expect { old_executed.reload }.to raise_error(ActiveRecord::RecordNotFound)
+    end
+  end
+
+  describe '.reschedule_paused' do
+    it 'resets rows overdue past the window so a resumed account replays them instead of expiring' do
+      expired = create(:automation_rule_pending_execution, account: account, conversation: conversation, due_at: 5.days.ago)
+      within_window = create(:automation_rule_pending_execution, account: account, due_at: 2.days.ago)
+
+      described_class.reschedule_paused(account)
+
+      expect(expired.reload.due_at).to be_within(5.seconds).of(Time.current)
+      expect(within_window.reload.due_at).to be_within(5.seconds).of(2.days.ago)
+    end
+  end
+end

spec/models/automation_rule_spec.rb

@@ -137,4 +137,118 @@ RSpec.describe AutomationRule do
       end
     end
   end
+
+  describe 'execution_delay validations' do
+    let(:rule) { build(:automation_rule, account: create(:account)) }
+
+    it 'allows nil (immediate execution)' do
+      rule.execution_delay = nil
+      expect(rule).to be_valid
+    end
+
+    it 'allows delays between 10 minutes and 30 days' do
+      rule.execution_delay = 240
+      expect(rule).to be_valid
+    end
+
+    it 'rejects delays below 10 minutes' do
+      rule.execution_delay = 5
+      expect(rule).not_to be_valid
+      expect(rule.errors[:execution_delay]).to be_present
+    end
+
+    it 'rejects delays above 30 days' do
+      rule.execution_delay = 43_201
+      expect(rule).not_to be_valid
+    end
+
+    it 'rejects non-integer delays' do
+      rule.execution_delay = 10.5
+      expect(rule).not_to be_valid
+    end
+
+    it 'rejects a delay combined with an attribute_changed condition' do
+      rule.execution_delay = 60
+      rule.conditions = [{ 'attribute_key' => 'status', 'filter_operator' => 'attribute_changed',
+                           'values' => { 'from' => ['open'], 'to' => ['pending'] }, 'query_operator' => nil }]
+      expect(rule).not_to be_valid
+      expect(rule.errors[:execution_delay]).to include('cannot be used with attribute_changed conditions.')
+    end
+
+    it 'rejects a delayed conversation-level rule with a mutable non-status condition' do
+      rule.event_name = 'conversation_updated'
+      rule.execution_delay = 60
+      rule.conditions = [{ 'attribute_key' => 'priority', 'filter_operator' => 'equal_to', 'values' => ['urgent'], 'query_operator' => nil }]
+      expect(rule).not_to be_valid
+      expect(rule.errors[:execution_delay]).to include('only supports status and inbox conditions for conversation-level events.')
+    end
+
+    it 'allows a delayed conversation-level rule with only status conditions' do
+      rule.event_name = 'conversation_updated'
+      rule.execution_delay = 60
+      rule.conditions = [{ 'attribute_key' => 'status', 'filter_operator' => 'equal_to', 'values' => ['pending'], 'query_operator' => nil }]
+      expect(rule).to be_valid
+    end
+
+    it 'allows a delayed conversation_created rule (arms on creation)' do
+      rule.event_name = 'conversation_created'
+      rule.execution_delay = 10
+      rule.conditions = [{ 'attribute_key' => 'status', 'filter_operator' => 'equal_to', 'values' => ['open'], 'query_operator' => nil }]
+      expect(rule).to be_valid
+    end
+
+    it 'allows a delayed conversation-level rule scoped by status and inbox (immutable)' do
+      rule.event_name = 'conversation_updated'
+      rule.execution_delay = 60
+      rule.conditions = [{ 'attribute_key' => 'status', 'filter_operator' => 'equal_to', 'values' => ['pending'], 'query_operator' => 'AND' },
+                         { 'attribute_key' => 'inbox_id', 'filter_operator' => 'equal_to', 'values' => [1], 'query_operator' => nil }]
+      expect(rule).to be_valid
+    end
+
+    it 'allows a delayed message_created rule with a non-status condition' do
+      rule.event_name = 'message_created'
+      rule.execution_delay = 60
+      rule.conditions = [{ 'attribute_key' => 'message_type', 'filter_operator' => 'equal_to', 'values' => ['outgoing'], 'query_operator' => nil }]
+      expect(rule).to be_valid
+    end
+  end
+
+  describe 'discarding stale pending executions on edit' do
+    let(:account) { create(:account) }
+    let(:conversation) { create(:conversation, account: account, status: :pending) }
+    let(:status_condition) { { 'attribute_key' => 'status', 'filter_operator' => 'equal_to', 'values' => ['pending'], 'query_operator' => nil } }
+    let(:rule) do
+      create(:automation_rule, account: account, event_name: 'conversation_updated', execution_delay: 60,
+                               conditions: [status_condition], actions: [{ 'action_name' => 'add_label', 'action_params' => ['stale'] }])
+    end
+
+    before { AutomationRulePendingExecution.schedule(rule: rule, conversation: conversation) }
+
+    it 'discards armed rows when the actions change' do
+      rule.update!(actions: [{ 'action_name' => 'add_label', 'action_params' => ['urgent'] }])
+      expect(rule.pending_executions.pending).to be_empty
+    end
+
+    it 'discards armed rows when the delay changes' do
+      rule.update!(execution_delay: 120)
+      expect(rule.pending_executions.pending).to be_empty
+    end
+
+    it 'discards a stale processing row that the sweep would otherwise reclaim' do
+      rule.pending_executions.first.update!(status: :processing)
+      rule.update!(actions: [{ 'action_name' => 'add_label', 'action_params' => ['urgent'] }])
+      expect(rule.pending_executions.armed).to be_empty
+    end
+
+    it 'frees the episode slot so the new definition re-arms for the same episode' do
+      rule.update!(actions: [{ 'action_name' => 'add_label', 'action_params' => ['urgent'] }])
+      AutomationRulePendingExecution.schedule(rule: rule, conversation: conversation)
+      expect(rule.pending_executions.pending.count).to eq(1)
+    end
+
+    it 'leaves armed rows untouched on a name-only edit' do
+      rule.update!(name: 'Renamed rule')
+      expect(rule.pending_executions.pending.count).to eq(1)
+    end
+  end
 end

spec/models/conversation_spec.rb

@@ -1230,4 +1230,28 @@ RSpec.describe Conversation do
       end
     end
   end
+
+  describe '#status_changed_at' do
+    let(:conversation) { create(:conversation) }
+
+    it 'is set on create' do
+      expect(conversation.status_changed_at).to be_present
+    end
+
+    it 'is updated on every status transition' do
+      original = conversation.status_changed_at
+
+      travel_to(1.hour.from_now) { conversation.update!(status: :resolved) }
+
+      expect(conversation.reload.status_changed_at).to be > original
+    end
+
+    it 'is untouched by non-status saves' do
+      original = conversation.status_changed_at
+
+      travel_to(1.hour.from_now) { conversation.update!(priority: :high) }
+
+      expect(conversation.reload.status_changed_at).to be_within(1.second).of(original)
+    end
+  end
 end