fix(inboxes): stop disabled continuity mail sends

# Pull Request Template

## Description

Locks the agent quota check to the account row while creating account
users. This fixes a race where concurrent agent-create requests could
all observe the same remaining seat before any `account_users` row was
inserted.

The API continues to return the existing `402 Account limit exceeded.
Please purchase more licenses` response when the limit is reached. Bulk
create now preflights the requested email count while holding the
account lock, then creates each agent through the same locked builder
path. The Enterprise custom-role hook now no-ops when create did not
produce an agent.

Fixes:
[CW-7039](https://linear.app/chatwoot/issue/CW-7039/race-condition-in-agent-creation-bypasses-plan-agent-seat-limit)

## Type of change

- [x] Bug fix (non-breaking change which fixes an issue)

## How Has This Been Tested?

- `POSTGRES_DATABASE=chatwoot_test_c20f_agent_quota REDIS_DB=9 bundle
exec rspec spec/builders/agent_builder_spec.rb
spec/enterprise/builders/agent_builder_spec.rb
spec/controllers/api/v1/accounts/agents_controller_spec.rb
spec/enterprise/controllers/api/v1/accounts/agents_controller_spec.rb
spec/enterprise/controllers/enterprise/api/v1/accounts/agents_controller_spec.rb`
- `bundle exec rubocop app/builders/agent_builder.rb
app/controllers/api/v1/accounts/agents_controller.rb
enterprise/app/controllers/enterprise/api/v1/accounts/agents_controller.rb
spec/builders/agent_builder_spec.rb
spec/enterprise/controllers/api/v1/accounts/agents_controller_spec.rb`
- `git diff --check`
- One-off threaded Rails validation with 8 concurrent `AgentBuilder`
calls against an account with one remaining seat: `created: 1`,
`limited: 7`, final `count=2`, `limit=2`.

## Checklist:

- [x] My code follows the style guidelines of this project
- [x] I have performed a self-review of my code
- [x] I have commented on my code, particularly in hard-to-understand
areas
- [ ] I have made corresponding changes to the documentation
- [x] My changes generate no new warnings
- [x] I have added tests that prove my fix is effective or that my
feature works
- [x] New and existing unit tests pass locally with my changes
- [ ] Any dependent changes have been merged and published in downstream
modules

Co-authored-by: Muhsin Keloth <muhsinkeramam@gmail.com>

app/builders/agent_builder.rb

@@ -2,6 +2,14 @@
 # It initializes with necessary attributes and provides a perform method
 # to create a user and account user in a transaction.
 class AgentBuilder
+  LIMIT_EXCEEDED_MESSAGE = 'Account limit exceeded. Please purchase more licenses'.freeze
+
+  class LimitExceededError < StandardError
+    def initialize
+      super(AgentBuilder::LIMIT_EXCEEDED_MESSAGE)
+    end
+  end
+
   # Initializes an AgentBuilder with necessary attributes.
   # @param email [String] the email of the user.
   # @param name [String] the name of the user.
@@ -14,15 +22,23 @@ class AgentBuilder
   # Creates a user and account user in a transaction.
   # @return [User] the created user.
   def perform
-    ActiveRecord::Base.transaction do
-      @user = find_or_create_user
-      create_account_user
+    account.with_lock do
+      raise LimitExceededError unless can_add_agent?
+
+      ActiveRecord::Base.transaction do
+        @user = find_or_create_user
+        create_account_user
+      end
     end
     @user
   end
 
   private
 
+  def can_add_agent?
+    account.usage_limits[:agents] > account.account_users.count
+  end
+
   # Finds a user by email or creates a new one with a temporary password.
   # @return [User] the found or created user.
   def find_or_create_user

app/builders/campaigns/campaign_conversation_builder.rb

@@ -3,6 +3,8 @@ class Campaigns::CampaignConversationBuilder
 
   def perform
     @contact_inbox = ContactInbox.find(@contact_inbox_id)
+    return unless @contact_inbox.inbox.active?
+
     @campaign = @contact_inbox.inbox.campaigns.find_by!(display_id: campaign_display_id)
 
     ActiveRecord::Base.transaction do

app/builders/conversation_builder.rb

@@ -2,6 +2,8 @@ class ConversationBuilder
   pattr_initialize [:params!, :contact_inbox!]
 
   def perform
+    raise CustomExceptions::InboxDisabled unless @contact_inbox.inbox.active?
+
     look_up_exising_conversation || create_new_conversation
   end
 

app/builders/messages/facebook/message_builder.rb

@@ -20,6 +20,7 @@ class Messages::Facebook::MessageBuilder < Messages::Messenger::MessageBuilder
   def perform
     # This channel might require reauthorization, may be owner might have changed the fb password
     return if @inbox.channel.reauthorization_required?
+    return unless @inbox.active?
 
     ActiveRecord::Base.transaction do
       build_contact_inbox

app/builders/messages/instagram/base_message_builder.rb

@@ -10,6 +10,7 @@ class Messages::Instagram::BaseMessageBuilder < Messages::Messenger::MessageBuil
 
   def perform
     return if @inbox.channel.reauthorization_required?
+    return unless @inbox.active?
 
     ActiveRecord::Base.transaction do
       build_message

app/builders/messages/message_builder.rb

@@ -22,14 +22,15 @@ class Messages::MessageBuilder
   end
 
   def perform
+    raise CustomExceptions::InboxDisabled unless @conversation.inbox.active?
+
     @message = @conversation.messages.build(message_params)
     process_attachments
     process_emails
     # When the message has no quoted content, it will just be rendered as a regular message
     # The frontend is equipped to handle this case
     process_email_content
-    @message.save!
-    @message
+    @message.tap(&:save!)
   end
 
   private

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

@@ -1,8 +1,6 @@
 class Api::V1::Accounts::AgentsController < Api::V1::Accounts::BaseController
   before_action :fetch_agent, except: [:create, :index, :bulk_create]
   before_action :check_authorization
-  before_action :validate_limit, only: [:create]
-  before_action :validate_limit_for_bulk_create, only: [:bulk_create]
 
   def index
     @agents = agents
@@ -20,6 +18,8 @@ class Api::V1::Accounts::AgentsController < Api::V1::Accounts::BaseController
     )
 
     @agent = builder.perform
+  rescue AgentBuilder::LimitExceededError => e
+    render_payment_required(e.message)
   end
 
   def update
@@ -36,25 +36,13 @@ class Api::V1::Accounts::AgentsController < Api::V1::Accounts::BaseController
   def bulk_create
     emails = params[:emails]
 
-    emails.each do |email|
-      builder = AgentBuilder.new(
-        email: email,
-        name: email.split('@').first,
-        inviter: current_user,
-        account: Current.account
-      )
-      begin
-        builder.perform
-      rescue ActiveRecord::RecordInvalid => e
-        Rails.logger.info "[Agent#bulk_create] ignoring email #{email}, errors: #{e.record.errors}"
-      end
-    end
-
+    bulk_create_agents(emails)
     # This endpoint is used to bulk create agents during onboarding
     # onboarding_step key in present in Current account custom attributes, since this is a one time operation
-    Current.account.custom_attributes.delete('onboarding_step')
-    Current.account.save!
+    clear_onboarding_step
     head :ok
+  rescue AgentBuilder::LimitExceededError => e
+    render_payment_required(e.message)
   end
 
   private
@@ -87,22 +75,33 @@ class Api::V1::Accounts::AgentsController < Api::V1::Accounts::BaseController
     @agents ||= Current.account.users.order_by_full_name.includes(:account_users, { avatar_attachment: [:blob] })
   end
 
-  def validate_limit_for_bulk_create
-    limit_available = params[:emails].count <= available_agent_count
+  def bulk_create_agents(emails)
+    Current.account.with_lock do
+      raise AgentBuilder::LimitExceededError if emails.count > available_agent_count
 
-    render_payment_required('Account limit exceeded. Please purchase more licenses') unless limit_available
+      emails.each { |email| create_agent_from_email(email) }
+    end
   end
 
-  def validate_limit
-    render_payment_required('Account limit exceeded. Please purchase more licenses') unless can_add_agent?
+  def create_agent_from_email(email)
+    builder = AgentBuilder.new(
+      email: email,
+      name: email.split('@').first,
+      inviter: current_user,
+      account: Current.account
+    )
+    builder.perform
+  rescue ActiveRecord::RecordInvalid => e
+    Rails.logger.info "[Agent#bulk_create] ignoring email #{email}, errors: #{e.record.errors}"
+  end
+
+  def clear_onboarding_step
+    Current.account.custom_attributes.delete('onboarding_step')
+    Current.account.save!
   end
 
   def available_agent_count
-    Current.account.usage_limits[:agents] - agents.count
-  end
-
-  def can_add_agent?
-    available_agent_count.positive?
+    Current.account.usage_limits[:agents] - Current.account.account_users.count
   end
 
   def delete_user_record(agent)

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

@@ -3,7 +3,6 @@ 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
@@ -49,9 +48,6 @@ 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
@@ -59,27 +55,13 @@ 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(
-      *permitted_attributes,
+      :name, :description, :event_name, :active,
       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/controllers/api/v1/accounts/conversations/messages_controller.rb

@@ -1,5 +1,6 @@
 class Api::V1::Accounts::Conversations::MessagesController < Api::V1::Accounts::Conversations::BaseController
   before_action :ensure_api_inbox, only: :update
+  before_action :ensure_inbox_active, only: [:create, :retry]
 
   def index
     @messages = message_finder.perform
@@ -9,6 +10,8 @@ class Api::V1::Accounts::Conversations::MessagesController < Api::V1::Accounts::
     user = Current.user || @resource
     mb = Messages::MessageBuilder.new(user, @conversation, params)
     @message = mb.perform
+  rescue CustomExceptions::InboxDisabled
+    render_inbox_disabled_error
   rescue StandardError => e
     render_could_not_create_error(e.message)
   end
@@ -32,6 +35,8 @@ class Api::V1::Accounts::Conversations::MessagesController < Api::V1::Accounts::
     service.perform
     message.update!(content_attributes: {})
     ::SendReplyJob.perform_later(message.id)
+  rescue CustomExceptions::InboxDisabled
+    render_inbox_disabled_error
   rescue StandardError => e
     render_could_not_create_error(e.message)
   end
@@ -80,4 +85,8 @@ class Api::V1::Accounts::Conversations::MessagesController < Api::V1::Accounts::
     # Only API inboxes can update messages
     render json: { error: 'Message status update is only allowed for API inboxes' }, status: :forbidden unless @conversation.inbox.api?
   end
+
+  def ensure_inbox_active
+    render_inbox_disabled_error unless @conversation.inbox.active?
+  end
 end

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

@@ -198,6 +198,7 @@ class Api::V1::Accounts::ConversationsController < Api::V1::Accounts::BaseContro
 
     @inbox = Current.account.inboxes.find(params[:inbox_id])
     authorize @inbox, :show?
+    render_inbox_disabled_error unless @inbox.active?
   end
 
   def contact
@@ -214,6 +215,7 @@ class Api::V1::Accounts::ConversationsController < Api::V1::Accounts::BaseContro
     # and deprecate the support of passing only source_id as the param
     @contact_inbox ||= ::ContactInbox.find_by!(source_id: params[:source_id])
     authorize @contact_inbox.inbox, :show?
+    render_inbox_disabled_error unless @contact_inbox.inbox.active?
   rescue ActiveRecord::RecordNotUnique
     render json: { error: 'source_id should be unique' }, status: :unprocessable_entity
   end
@@ -221,12 +223,7 @@ class Api::V1::Accounts::ConversationsController < Api::V1::Accounts::BaseContro
   def build_contact_inbox
     return if @inbox.blank? || @contact.blank?
 
-    ContactInboxBuilder.new(
-      contact: @contact,
-      inbox: @inbox,
-      source_id: params[:source_id],
-      hmac_verified: hmac_verified?
-    ).perform
+    ContactInboxBuilder.new(contact: @contact, inbox: @inbox, source_id: params[:source_id], hmac_verified: hmac_verified?).perform
   end
 
   def conversation_finder

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

@@ -193,7 +193,7 @@ class Api::V1::Accounts::InboxesController < Api::V1::Accounts::BaseController
   def normalized_branded_email_layout = params[:branded_email_layout] == 'null' ? nil : params[:branded_email_layout]
 
   def inbox_attributes
-    [:name, :avatar, :greeting_enabled, :greeting_message, :enable_email_collect, :csat_survey_enabled,
+    [:name, :avatar, :active, :greeting_enabled, :greeting_message, :enable_email_collect, :csat_survey_enabled,
      :enable_auto_assignment, :working_hours_enabled, :out_of_office_message, :timezone, :allow_messages_after_resolved,
      :lock_to_single_conversation, :portal_id, :sender_name_type, :business_name,
      { csat_config: [:display_type, :message, :button_text, :language,

app/controllers/api/v1/accounts/integrations/base_controller.rb

@@ -0,0 +1,9 @@
+class Api::V1::Accounts::Integrations::BaseController < Api::V1::Accounts::BaseController
+  private
+
+  # Managing an integration hook (create/update/destroy) is admin-only, enforced via HookPolicy.
+  # Subclasses opt in per action with `before_action :check_authorization, only: [...]`.
+  def check_authorization
+    authorize(:hook)
+  end
+end

app/controllers/api/v1/accounts/integrations/hooks_controller.rb

@@ -1,4 +1,4 @@
-class Api::V1::Accounts::Integrations::HooksController < Api::V1::Accounts::BaseController
+class Api::V1::Accounts::Integrations::HooksController < Api::V1::Accounts::Integrations::BaseController
   before_action :fetch_hook, except: [:create]
   before_action :check_authorization
 
@@ -35,10 +35,6 @@ class Api::V1::Accounts::Integrations::HooksController < Api::V1::Accounts::Base
     @hook = Current.account.hooks.find(params[:id])
   end
 
-  def check_authorization
-    authorize(:hook)
-  end
-
   def permitted_params
     params.require(:hook).permit(:app_id, :inbox_id, :status, settings: {})
   end

app/controllers/api/v1/accounts/integrations/linear_controller.rb

@@ -1,6 +1,7 @@
-class Api::V1::Accounts::Integrations::LinearController < Api::V1::Accounts::BaseController
+class Api::V1::Accounts::Integrations::LinearController < Api::V1::Accounts::Integrations::BaseController
   before_action :fetch_conversation, only: [:create_issue, :link_issue, :unlink_issue, :linked_issues]
   before_action :fetch_hook, only: [:destroy]
+  before_action :check_authorization, only: [:destroy]
 
   def destroy
     revoke_linear_token

app/controllers/api/v1/accounts/integrations/notion_controller.rb

@@ -1,5 +1,6 @@
-class Api::V1::Accounts::Integrations::NotionController < Api::V1::Accounts::BaseController
+class Api::V1::Accounts::Integrations::NotionController < Api::V1::Accounts::Integrations::BaseController
   before_action :fetch_hook, only: [:destroy]
+  before_action :check_authorization, only: [:destroy]
 
   def destroy
     @hook.destroy!

app/controllers/api/v1/accounts/integrations/shopify_controller.rb

@@ -1,7 +1,8 @@
-class Api::V1::Accounts::Integrations::ShopifyController < Api::V1::Accounts::BaseController
+class Api::V1::Accounts::Integrations::ShopifyController < Api::V1::Accounts::Integrations::BaseController
   include Shopify::IntegrationHelper
   before_action :setup_shopify_context, only: [:orders]
   before_action :fetch_hook, except: [:auth]
+  before_action :check_authorization, only: [:destroy]
   before_action :validate_contact, only: [:orders]
 
   def auth

app/controllers/api/v1/widget/base_controller.rb

@@ -90,4 +90,8 @@ class Api::V1::Widget::BaseController < ApplicationController
       message_type: :incoming
     }
   end
+
+  def ensure_inbox_active
+    render_inbox_disabled_error unless @web_widget.inbox.active?
+  end
 end

app/controllers/api/v1/widget/configs_controller.rb

@@ -1,4 +1,5 @@
 class Api::V1::Widget::ConfigsController < Api::V1::Widget::BaseController
+  before_action :ensure_inbox_active
   before_action :set_global_config
 
   def create

app/controllers/api/v1/widget/contacts_controller.rb

@@ -1,6 +1,7 @@
 class Api::V1::Widget::ContactsController < Api::V1::Widget::BaseController
   include WidgetHelper
 
+  before_action :ensure_inbox_active, only: [:update, :set_user, :destroy_custom_attributes]
   before_action :validate_hmac, only: [:set_user]
   before_action :validate_hmac_for_identified_update, only: [:update]
 

app/controllers/api/v1/widget/conversations_controller.rb

@@ -1,6 +1,12 @@
 class Api::V1::Widget::ConversationsController < Api::V1::Widget::BaseController
   include Events::Types
+
+  DISABLED_INBOX_ACTIONS = [
+    :create, :toggle_typing, :toggle_status, :set_custom_attributes, :destroy_custom_attributes, :transcript
+  ].freeze
+
   before_action :render_not_found_if_empty, only: [:toggle_typing, :toggle_status, :set_custom_attributes, :destroy_custom_attributes]
+  before_action :ensure_inbox_active, only: DISABLED_INBOX_ACTIONS
 
   def index
     @conversation = conversation

app/controllers/api/v1/widget/direct_uploads_controller.rb

@@ -1,6 +1,7 @@
 class Api::V1::Widget::DirectUploadsController < ActiveStorage::DirectUploadsController
   include WebsiteTokenHelper
   before_action :set_web_widget
+  before_action :ensure_inbox_active
   before_action :set_contact
 
   def create
@@ -8,4 +9,15 @@ class Api::V1::Widget::DirectUploadsController < ActiveStorage::DirectUploadsCon
 
     super
   end
+
+  private
+
+  def ensure_inbox_active
+    return if @web_widget.inbox.active?
+
+    render json: {
+      error: 'inbox_disabled',
+      message: 'This inbox is currently disabled'
+    }, status: :forbidden
+  end
 end

app/controllers/api/v1/widget/events_controller.rb

@@ -1,6 +1,8 @@
 class Api::V1::Widget::EventsController < Api::V1::Widget::BaseController
   include Events::Types
 
+  before_action :ensure_inbox_active
+
   def create
     Rails.configuration.dispatcher.dispatch(permitted_params[:name], Time.zone.now, contact_inbox: @contact_inbox,
                                                                                     event_info: permitted_params[:event_info].to_h.merge(event_info))

app/controllers/api/v1/widget/integrations/dyte_controller.rb

@@ -1,4 +1,5 @@
 class Api::V1::Widget::Integrations::DyteController < Api::V1::Widget::BaseController
+  before_action :ensure_inbox_active
   before_action :set_message
 
   def add_participant_to_meeting

app/controllers/api/v1/widget/labels_controller.rb

@@ -1,4 +1,6 @@
 class Api::V1::Widget::LabelsController < Api::V1::Widget::BaseController
+  before_action :ensure_inbox_active
+
   def create
     if conversation.present? && label_defined_in_account?
       conversation.label_list.add(permitted_params[:label])

app/controllers/api/v1/widget/messages_controller.rb

@@ -1,4 +1,5 @@
 class Api::V1::Widget::MessagesController < Api::V1::Widget::BaseController
+  before_action :ensure_inbox_active, only: [:create, :update]
   before_action :set_conversation, only: [:create]
   before_action :set_message, only: [:update]
 

app/controllers/concerns/request_exception_handler.rb

@@ -9,6 +9,7 @@ module RequestExceptionHandler
 
   included do
     rescue_from ActiveRecord::RecordInvalid, with: :render_record_invalid
+    rescue_from CustomExceptions::InboxDisabled, with: :render_inbox_disabled_error
     rescue_from CustomExceptions::Inbox::LimitExceeded, with: :render_error_response
   end
 
@@ -45,6 +46,13 @@ module RequestExceptionHandler
     render json: { error: sanitized_error_message(error) }, status: :unprocessable_entity
   end
 
+  def render_inbox_disabled_error(_exception = nil)
+    render json: {
+      error: 'inbox_disabled',
+      message: 'This inbox is currently disabled'
+    }, status: :forbidden
+  end
+
   def render_payment_required(message)
     render json: { error: message }, status: :payment_required
   end

app/controllers/platform/api/v1/inboxes_controller.rb

@@ -0,0 +1,34 @@
+class Platform::Api::V1::InboxesController < PlatformController
+  before_action :set_account
+  before_action :validate_account_permissible
+  before_action :set_inbox
+
+  def disable
+    update_active_state(false)
+  end
+
+  def enable
+    update_active_state(true)
+  end
+
+  private
+
+  def set_account
+    @account = Account.find(params[:account_id])
+  end
+
+  def validate_account_permissible
+    return if @platform_app.platform_app_permissibles.find_by(permissible: @account)
+
+    render json: { error: 'Non permissible resource' }, status: :unauthorized
+  end
+
+  def set_inbox
+    @inbox = @account.inboxes.find(params[:id])
+  end
+
+  def update_active_state(active)
+    @inbox.update!(active: active)
+    render json: { success: true, inbox_id: @inbox.id, active: @inbox.active }
+  end
+end

app/controllers/public/api/v1/inboxes/contacts_controller.rb

@@ -1,5 +1,6 @@
 class Public::Api::V1::Inboxes::ContactsController < Public::Api::V1::InboxesController
   before_action :contact_inbox, except: [:create]
+  before_action :ensure_inbox_active, only: [:create, :update]
   before_action :process_hmac
 
   def show; end
@@ -50,4 +51,8 @@ class Public::Api::V1::Inboxes::ContactsController < Public::Api::V1::InboxesCon
   def permitted_params
     params.permit(:identifier, :identifier_hash, :email, :name, :avatar_url, :phone_number, custom_attributes: {})
   end
+
+  def ensure_inbox_active
+    render_inbox_disabled_error unless @inbox_channel.inbox.active?
+  end
 end

app/controllers/public/api/v1/inboxes/conversations_controller.rb

@@ -1,6 +1,7 @@
 class Public::Api::V1::Inboxes::ConversationsController < Public::Api::V1::InboxesController
   include Events::Types
   before_action :set_conversation, only: [:toggle_typing, :update_last_seen, :show, :toggle_status]
+  before_action :ensure_inbox_active, only: [:create, :toggle_typing, :toggle_status]
 
   def index
     @conversations = @contact_inbox.hmac_verified? ? @contact_inbox.contact.conversations : @contact_inbox.conversations
@@ -64,4 +65,8 @@ class Public::Api::V1::Inboxes::ConversationsController < Public::Api::V1::Inbox
   def conversation_params
     params.permit(custom_attributes: {})
   end
+
+  def ensure_inbox_active
+    render_inbox_disabled_error unless @contact_inbox.inbox.active?
+  end
 end

app/controllers/public/api/v1/inboxes/messages_controller.rb

@@ -1,5 +1,6 @@
 class Public::Api::V1::Inboxes::MessagesController < Public::Api::V1::InboxesController
   before_action :set_message, only: [:update]
+  before_action :ensure_inbox_active, only: [:create, :update]
 
   def index
     @messages = @conversation.nil? ? [] : message_finder.perform
@@ -70,4 +71,8 @@ class Public::Api::V1::Inboxes::MessagesController < Public::Api::V1::InboxesCon
   def check_csat_locked
     (Time.zone.now.to_date - @message.created_at.to_date).to_i > 14 and @message.content_type == 'input_csat'
   end
+
+  def ensure_inbox_active
+    render_inbox_disabled_error unless @conversation.inbox.active?
+  end
 end

app/controllers/widgets_controller.rb

@@ -5,6 +5,7 @@ class WidgetsController < ActionController::Base
   before_action :set_global_config
   before_action :set_web_widget
   before_action :ensure_account_is_active
+  before_action :ensure_inbox_active
   before_action :ensure_location_is_supported
   before_action :set_token
   before_action :set_contact
@@ -62,6 +63,10 @@ class WidgetsController < ActionController::Base
     render json: { error: 'Account is suspended' }, status: :unauthorized unless @web_widget.inbox.account.active?
   end
 
+  def ensure_inbox_active
+    head :not_found unless @web_widget.inbox.active?
+  end
+
   def ensure_location_is_supported; end
 
   def additional_attributes

app/javascript/dashboard/components-next/Conversation/InboxName.vue

@@ -1,4 +1,5 @@
 <script setup>
+import { useI18n } from 'vue-i18n';
 import ChannelIcon from 'dashboard/components-next/icon/ChannelIcon.vue';
 
 defineProps({
@@ -7,13 +8,21 @@ defineProps({
     default: () => {},
   },
 });
+
+const { t } = useI18n();
 </script>
 
 <template>
-  <div :title="inbox.name" class="flex items-center gap-0.5 min-w-0">
+  <div :title="inbox.name" class="flex items-center gap-1 min-w-0">
     <ChannelIcon :inbox="inbox" class="size-4 flex-shrink-0 text-n-slate-11" />
     <span class="truncate text-body-main text-n-slate-11">
       {{ inbox.name }}
     </span>
+    <span
+      v-if="inbox.active === false"
+      class="inline-flex h-4 shrink-0 items-center rounded-md bg-n-alpha-2 px-1 text-label-mini font-medium text-n-slate-11"
+    >
+      {{ t('INBOX_MGMT.DISABLED') }}
+    </span>
   </div>
 </template>

app/javascript/dashboard/components/widgets/InboxName.vue

@@ -1,4 +1,5 @@
 <script setup>
+import { useI18n } from 'vue-i18n';
 import ChannelIcon from 'dashboard/components-next/icon/ChannelIcon.vue';
 
 defineProps({
@@ -7,13 +8,21 @@ defineProps({
     default: () => {},
   },
 });
+
+const { t } = useI18n();
 </script>
 
 <template>
-  <div :title="inbox.name" class="flex items-center gap-0.5 min-w-0">
+  <div :title="inbox.name" class="flex items-center gap-1 min-w-0">
     <ChannelIcon :inbox="inbox" class="size-4 flex-shrink-0 text-n-slate-11" />
     <span class="truncate text-label-small text-n-slate-11">
       {{ inbox.name }}
     </span>
+    <span
+      v-if="inbox.active === false"
+      class="inline-flex h-4 shrink-0 items-center rounded-md bg-n-alpha-2 px-1 text-label-mini font-medium text-n-slate-11"
+    >
+      {{ t('INBOX_MGMT.DISABLED') }}
+    </span>
   </div>
 </template>

app/javascript/dashboard/featureFlags.js

@@ -14,7 +14,6 @@ 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,12 +208,6 @@ 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,35 +28,6 @@
           "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"
         },
@@ -78,13 +49,7 @@
         "CREATED_ON": "Created on",
         "ACTIONS": "Actions"
       },
-      "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."
+      "404": "No automation rules found"
     },
     "DELETE": {
       "TITLE": "Delete Automation Rule",

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

@@ -4,6 +4,7 @@
     "DESCRIPTION": "A channel is the mode of communication your customer chooses to interact with you. An inbox is where you manage interactions for a specific channel. It can include communications from various sources such as email, live chat, and social media.",
     "LEARN_MORE": "Learn more about inboxes",
     "COUNT": "{n} inbox | {n} inboxes",
+    "DISABLED": "Disabled",
     "SEARCH_PLACEHOLDER": "Search inboxes...",
     "NO_RESULTS": "No inboxes found matching your search",
     "RECONNECTION_REQUIRED": "Your inbox is disconnected. You won't receive new messages until you reauthorize it.",

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

@@ -10,7 +10,6 @@ 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,11 +6,6 @@ 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,
@@ -19,7 +14,6 @@ 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({
@@ -77,28 +71,6 @@ 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();
@@ -106,7 +78,6 @@ const { operators } = useOperators();
 const dialogRef = ref(null);
 const conditionsRef = useTemplateRef('conditionsRef');
 const errors = ref({});
-const isDelayed = ref(false);
 
 const isEditMode = computed(() => props.mode === 'edit');
 
@@ -213,172 +184,6 @@ 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),
-  ];
-  // A private note is an outgoing message, so without this an internal note would read as a reply
-  // and arm the customer-unresponsive wait. Incoming messages are never private.
-  if (trigger.messageType === 'outgoing') {
-    conditions.push(buildTriggerCondition('private_note', [false]));
-  }
-  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,
   () => {
@@ -411,9 +216,8 @@ const syncCustomAttributeTypes = () => {
   });
 };
 
-const open = (executionDelay = null) => {
+const open = () => {
   resetValidation();
-  syncDelayFromDelay(executionDelay);
   dialogRef.value?.open();
 };
 
@@ -426,13 +230,8 @@ 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);
   }
 };
@@ -467,163 +266,84 @@ defineExpose({ open, close });
         :error="errors.description ? $t('AUTOMATION.ADD.FORM.DESC.ERROR') : ''"
         :placeholder="$t('AUTOMATION.ADD.FORM.DESC.PLACEHOLDER')"
       />
-      <!-- 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>
-          <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>
-        </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()"
+      <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"
             >
-              <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>
+              {{ 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 -->
       <!-- Actions Start -->
       <section>
         <label>

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

@@ -1,7 +1,6 @@
 <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';
@@ -44,16 +43,6 @@ 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,33 +34,29 @@ const {
 
 const { formatAutomation } = useEditableAutomation();
 
-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 open = () => formRef.value?.open();
 const close = () => formRef.value?.close();
 
 const onSave = (payload, mode) => {
   emit('saveAutomation', payload, mode);
 };
 
-watch(() => props.selectedResponse, syncAutomationFromSelected, {
-  immediate: true,
-});
+watch(
+  () => props.selectedResponse,
+  value => {
+    if (!value?.conditions) return;
+
+    manifestCustomAttributes();
+
+    automation.value = formatAutomation(
+      value,
+      allCustomAttributes.value,
+      automationTypes,
+      AUTOMATION_ACTION_TYPES
+    );
+  },
+  { immediate: true }
+);
 
 defineExpose({ open, close });
 </script>

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

@@ -35,31 +35,6 @@ 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);
 
@@ -77,14 +52,6 @@ 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');
@@ -107,7 +74,7 @@ const hideAddPopup = () => {
 
 const openEditPopup = response => {
   selectedAutomation.value = { ...response };
-  editDialogRef.value?.open(response);
+  editDialogRef.value?.open();
 };
 const hideEditPopup = () => {
   editDialogRef.value?.close();
@@ -161,11 +128,11 @@ const submitAutomation = async (payload, mode) => {
     hideAddPopup();
     hideEditPopup();
   } catch (error) {
-    const fallbackMessage =
+    const errorMessage =
       mode === 'edit'
         ? t('AUTOMATION.EDIT.API.ERROR_MESSAGE')
         : t('AUTOMATION.ADD.API.ERROR_MESSAGE');
-    useAlert(error?.response?.data?.error || fallbackMessage);
+    useAlert(errorMessage);
   }
 };
 const toggleAutomation = async ({ id, name, status }) => {
@@ -245,49 +212,25 @@ 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="[]"
+        :items="filteredRecords"
         :no-data-message="
           searchQuery ? $t('AUTOMATION.NO_RESULTS') : $t('AUTOMATION.LIST.404')
         "
       >
-        <template #row />
+        <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>
     </template>
 

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

@@ -142,10 +142,20 @@ const openDelete = inbox => {
             >
               <ChannelIcon class="size-6 text-n-slate-10" :inbox="inbox" />
             </div>
-            <div class="flex flex-col items-start gap-1">
-              <span class="block text-heading-3 text-n-slate-12 capitalize">
-                {{ inbox.name }}
-              </span>
+            <div class="flex flex-col items-start gap-1 min-w-0">
+              <div class="flex items-center gap-1.5 min-w-0">
+                <span
+                  class="block text-heading-3 text-n-slate-12 capitalize truncate"
+                >
+                  {{ inbox.name }}
+                </span>
+                <span
+                  v-if="inbox.active === false"
+                  class="inline-flex h-5 shrink-0 items-center rounded-md bg-n-alpha-2 px-1.5 text-label-mini font-medium text-n-slate-11"
+                >
+                  {{ $t('INBOX_MGMT.DISABLED') }}
+                </span>
+              </div>
               <ChannelName
                 :channel-type="inbox.channel_type"
                 :medium="inbox.medium"

app/javascript/widget/components/ChatFooter.vue

@@ -11,6 +11,8 @@ import { IFrameHelper } from '../helpers/utils';
 import { CHATWOOT_ON_START_CONVERSATION } from '../constants/sdkEvents';
 import { emitter } from 'shared/helpers/mitt';
 
+const TRANSCRIPT_COOLDOWN_MS = 15000;
+
 export default {
   components: {
     ChatInputWrap,
@@ -24,6 +26,9 @@ export default {
   data() {
     return {
       inReplyTo: null,
+      isSendingTranscript: false,
+      transcriptCooldown: false,
+      transcriptCooldownTimer: null,
     };
   },
   computed: {
@@ -57,6 +62,9 @@ export default {
   mounted() {
     emitter.on(BUS_EVENTS.TOGGLE_REPLY_TO_MESSAGE, this.toggleReplyTo);
   },
+  beforeUnmount() {
+    clearTimeout(this.transcriptCooldownTimer);
+  },
   methods: {
     ...mapActions('conversation', ['sendMessage', 'sendAttachment']),
     ...mapActions('conversationAttributes', ['getAttributes']),
@@ -90,19 +98,35 @@ export default {
     toggleReplyTo(message) {
       this.inReplyTo = message;
     },
+    startTranscriptCooldown() {
+      this.transcriptCooldown = true;
+      clearTimeout(this.transcriptCooldownTimer);
+      this.transcriptCooldownTimer = setTimeout(() => {
+        this.transcriptCooldown = false;
+      }, TRANSCRIPT_COOLDOWN_MS);
+    },
     async sendTranscript() {
-      if (this.hasEmail) {
-        try {
-          await sendEmailTranscript();
-          emitter.emit(BUS_EVENTS.SHOW_ALERT, {
-            message: this.$t('EMAIL_TRANSCRIPT.SEND_EMAIL_SUCCESS'),
-            type: 'success',
-          });
-        } catch (error) {
-          emitter.$emit(BUS_EVENTS.SHOW_ALERT, {
-            message: this.$t('EMAIL_TRANSCRIPT.SEND_EMAIL_ERROR'),
-          });
-        }
+      if (
+        !this.hasEmail ||
+        this.isSendingTranscript ||
+        this.transcriptCooldown
+      ) {
+        return;
+      }
+      this.isSendingTranscript = true;
+      try {
+        await sendEmailTranscript();
+        this.startTranscriptCooldown();
+        emitter.emit(BUS_EVENTS.SHOW_ALERT, {
+          message: this.$t('EMAIL_TRANSCRIPT.SEND_EMAIL_SUCCESS'),
+          type: 'success',
+        });
+      } catch (error) {
+        emitter.emit(BUS_EVENTS.SHOW_ALERT, {
+          message: this.$t('EMAIL_TRANSCRIPT.SEND_EMAIL_ERROR'),
+        });
+      } finally {
+        this.isSendingTranscript = false;
       }
     },
   },
@@ -144,6 +168,7 @@ export default {
       v-if="showEmailTranscriptButton"
       type="clear"
       class="font-normal"
+      :disabled="isSendingTranscript || transcriptCooldown"
       @click="sendTranscript"
     >
       {{ $t('EMAIL_TRANSCRIPT.BUTTON_TEXT') }}

app/jobs/automation_rules/process_pending_execution_job.rb

@@ -1,68 +0,0 @@
-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
-
-  # Marked before the actions run: a row that dies here stays `executing`, which no sweep reclaims,
-  # so a message/email/webhook is never sent twice. Everything up to this point is still retryable.
-  def execute(pending_execution)
-    pending_execution.update!(status: :executing)
-    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

@@ -1,11 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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,
-                abandoned: AutomationRulePendingExecution.abandoned.count, 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:, abandoned:, started_at:)
-    summary = { event: 'completed', enqueued: enqueued, capped: capped, purged: purged, abandoned: abandoned,
-                duration_ms: ((Time.current - started_at) * 1000).round }
-    Rails.logger.info("[AutomationRules::TriggerPendingExecutionsJob] #{summary.to_json}")
-  end
-end

app/jobs/conversation_reply_email_job.rb

@@ -4,6 +4,7 @@ class ConversationReplyEmailJob < ApplicationJob
   def perform(conversation_id, last_queued_id)
     conversation = Conversation.find(conversation_id)
     return unless conversation.account.active?
+    return unless conversation.inbox.active?
 
     if conversation.messages.incoming&.last&.content_type == 'incoming_email'
       ConversationReplyMailer.with(account: conversation.account).reply_without_summary(conversation, last_queued_id).deliver_later

app/jobs/inboxes/fetch_imap_email_inboxes_job.rb

@@ -13,6 +13,7 @@ class Inboxes::FetchImapEmailInboxesJob < ApplicationJob
 
   def should_fetch_emails?(inbox)
     return false if inbox.account.suspended?
+    return false unless inbox.active?
     return false unless inbox.channel.imap_enabled
     return false if inbox.channel.reauthorization_required?
 

app/jobs/inboxes/fetch_imap_emails_job.rb

@@ -25,7 +25,7 @@ class Inboxes::FetchImapEmailsJob < MutexApplicationJob
   private
 
   def should_fetch_email?(channel)
-    channel.imap_enabled? && !channel.reauthorization_required?
+    channel.inbox.active? && channel.imap_enabled? && !channel.reauthorization_required?
   end
 
   def process_email_for_channel(channel, interval)

app/jobs/send_reply_job.rb

@@ -1,6 +1,8 @@
 class SendReplyJob < ApplicationJob
   queue_as :high
 
+  INBOX_DISABLED_ERROR = 'This inbox is currently disabled'.freeze
+
   CHANNEL_SERVICES = {
     'Channel::TwitterProfile' => ::Twitter::SendOnTwitterService,
     'Channel::TwilioSms' => ::Twilio::SendOnTwilioService,
@@ -18,6 +20,7 @@ class SendReplyJob < ApplicationJob
   def perform(message_id)
     message = Message.find(message_id)
     channel_name = message.conversation.inbox.channel.class.to_s
+    return handle_disabled_inbox(message, channel_name) unless message.inbox.active?
 
     return send_on_facebook_page(message) if channel_name == 'Channel::FacebookPage'
 
@@ -29,6 +32,61 @@ class SendReplyJob < ApplicationJob
 
   private
 
+  def handle_disabled_inbox(message, channel_name)
+    return unless send_service_available?(channel_name)
+    return unless deliverable_reply?(message, channel_name)
+
+    mark_message_failed(message)
+  end
+
+  def send_service_available?(channel_name)
+    channel_name == 'Channel::FacebookPage' || CHANNEL_SERVICES.key?(channel_name)
+  end
+
+  def deliverable_reply?(message, channel_name)
+    return false unless deliverable_message?(message)
+    return message.email_notifiable_message? if email_channel?(channel_name)
+    return email_notification_deliverable?(message, channel_name) if email_notification_channel?(channel_name)
+
+    true
+  end
+
+  def deliverable_message?(message)
+    return false if message.private?
+    return false unless message.outgoing? || message.template?
+    return false if message.source_id.present?
+    return false if message.content_type == 'voice_call'
+
+    true
+  end
+
+  def email_channel?(channel_name)
+    channel_name == 'Channel::Email'
+  end
+
+  def email_notification_channel?(channel_name)
+    %w[Channel::WebWidget Channel::Api].include?(channel_name)
+  end
+
+  def email_notification_deliverable?(message, channel_name)
+    return false unless message.email_notifiable_message?
+    return false if message.conversation.contact.email.blank?
+    return false unless message.account.within_email_rate_limit?
+
+    email_notification_enabled?(message.inbox, channel_name)
+  end
+
+  def email_notification_enabled?(inbox, channel_name)
+    return inbox.channel.continuity_via_email if channel_name == 'Channel::WebWidget'
+    return inbox.account.feature_enabled?('email_continuity_on_api_channel') if channel_name == 'Channel::Api'
+
+    false
+  end
+
+  def mark_message_failed(message)
+    Messages::StatusUpdateService.new(message, 'failed', INBOX_DISABLED_ERROR).perform
+  end
+
   def send_on_facebook_page(message)
     if message.conversation.additional_attributes['type'] == 'instagram_direct_message'
       ::Instagram::Messenger::SendOnInstagramService.new(message: message).perform

app/jobs/trigger_scheduled_items_job.rb

@@ -19,9 +19,6 @@ 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/jobs/webhooks/instagram_events_job.rb

@@ -57,9 +57,11 @@ class Webhooks::InstagramEventsJob < MutexApplicationJob
 
       next if channel.blank?
 
-      if (event_name = event_name(messaging))
-        send(event_name, messaging, channel)
-      end
+      event_name = event_name(messaging)
+      next if event_name.blank?
+      next unless channel.inbox.active? || event_name == :read
+
+      send(event_name, messaging, channel)
     end
   end
 
@@ -126,7 +128,7 @@ class Webhooks::InstagramEventsJob < MutexApplicationJob
   end
 
   def event_name(messaging)
-    @event_name ||= SUPPORTED_EVENTS.find { |key| messaging.key?(key) }
+    SUPPORTED_EVENTS.find { |key| messaging.key?(key) }
   end
 
   def message(messaging, channel)

app/jobs/webhooks/line_events_job.rb

@@ -4,6 +4,7 @@ class Webhooks::LineEventsJob < ApplicationJob
   def perform(params: {}, signature: '', post_body: '')
     @params = params
     return unless valid_event_payload?
+    return unless @channel.inbox.active?
     return unless valid_post_body?(post_body, signature)
 
     Line::IncomingMessageService.new(inbox: @channel.inbox, params: @params['line'].with_indifferent_access).perform

app/jobs/webhooks/sms_events_job.rb

@@ -8,6 +8,7 @@ class Webhooks::SmsEventsJob < ApplicationJob
 
     channel = Channel::Sms.find_by(phone_number: params[:to])
     return unless channel
+    return if incoming_event?(params) && !channel.inbox.active?
 
     process_event_params(channel, params)
   end
@@ -25,4 +26,8 @@ class Webhooks::SmsEventsJob < ApplicationJob
   def delivery_event?(params)
     params[:type] == 'message-delivered' || params[:type] == 'message-failed'
   end
+
+  def incoming_event?(params)
+    params[:type] == 'message-received'
+  end
 end

app/jobs/webhooks/telegram_events_job.rb

@@ -6,7 +6,7 @@ class Webhooks::TelegramEventsJob < ApplicationJob
 
     channel = Channel::Telegram.find_by(bot_token: params[:bot_token])
 
-    if channel_is_inactive?(channel)
+    if channel_is_inactive?(channel, params)
       log_inactive_channel(channel, params)
       return
     end
@@ -16,13 +16,18 @@ class Webhooks::TelegramEventsJob < ApplicationJob
 
   private
 
-  def channel_is_inactive?(channel)
+  def channel_is_inactive?(channel, params)
     return true if channel.blank?
     return true unless channel.account.active?
+    return true unless channel.inbox.active? || update_message_event?(params)
 
     false
   end
 
+  def update_message_event?(params)
+    params.dig(:telegram, :edited_message).present? || params.dig(:telegram, :edited_business_message).present?
+  end
+
   def log_inactive_channel(channel, params)
     message = if channel&.id
                 "Account #{channel.account.id} is not active for channel #{channel.id}"

app/jobs/webhooks/tiktok_events_job.rb

@@ -21,6 +21,7 @@ class Webhooks::TiktokEventsJob < MutexApplicationJob
   def channel_is_inactive?
     return true if channel.blank?
     return true unless channel.account.active?
+    return true unless channel.inbox.active? || event_name == 'im_mark_read_msg'
 
     false
   end

app/jobs/webhooks/whatsapp_events_job.rb

@@ -8,7 +8,7 @@ class Webhooks::WhatsappEventsJob < MutexApplicationJob
   def perform(params = {})
     channel = find_channel_from_whatsapp_business_payload(params)
 
-    if channel_is_inactive?(channel)
+    if channel_is_inactive?(channel, params)
       Rails.logger.warn("Inactive WhatsApp channel: #{channel&.phone_number || "unknown - #{params[:phone_number]}"}")
       return
     end
@@ -124,15 +124,29 @@ class Webhooks::WhatsappEventsJob < MutexApplicationJob
     ].compact_blank.first
   end
 
-  def channel_is_inactive?(channel)
+  def channel_is_inactive?(channel, params)
     return true if channel.blank?
     # Only skip for embedded signup when reauth is required; manual flow uses API keys and should still receive webhooks
     return true if channel.reauthorization_required? && embedded_signup_channel?(channel)
     return true unless channel.account.active?
+    return true unless channel.inbox.active? || existing_message_update_event?(params)
 
     false
   end
 
+  def status_update_event?(params)
+    value = params.dig(:entry, 0, :changes, 0, :value) || params
+    value[:statuses].present?
+  end
+
+  def existing_message_update_event?(params)
+    status_update_event?(params) || call_event?(params)
+  end
+
+  def call_event?(params)
+    params.dig(:entry, 0, :changes, 0, :field) == 'calls'
+  end
+
   def embedded_signup_channel?(channel)
     (channel.provider_config || {}).to_h['source'] == 'embedded_signup'
   end

app/listeners/agent_bot_listener.rb

@@ -63,6 +63,8 @@ class AgentBotListener < BaseListener
   private
 
   def agent_bots_for(inbox, conversation = nil)
+    return [] unless inbox.active?
+
     bots = []
     bots << conversation.assignee_agent_bot if conversation&.assignee_agent_bot.present?
     inbox_bot = active_inbox_agent_bot(inbox)

app/listeners/automation_rule_listener.rb

@@ -18,6 +18,7 @@ class AutomationRuleListener < BaseListener
   def message_created(event)
     message = event.data[:message]
 
+    return unless message.inbox.active?
     return if ignore_message_created_event?(event)
 
     account = message.try(:account)
@@ -30,7 +31,7 @@ class AutomationRuleListener < BaseListener
     rules.each do |rule|
       conditions_match = ::AutomationRules::ConditionsFilterService.new(rule, message.conversation,
                                                                         { message: message, changed_attributes: changed_attributes }).perform
-      execute_rule(rule, account, message.conversation, message: message) if conditions_match.present?
+      ::AutomationRules::ActionService.new(rule, account, message.conversation).perform if conditions_match.present?
     end
   end
 
@@ -39,43 +40,21 @@ class AutomationRuleListener < BaseListener
   def process_conversation_event(event, event_name)
     return if performed_by_automation?(event)
 
-    auto_reply_skip_events = %w[conversation_created conversation_opened]
-    return if auto_reply_skip_events.include?(event_name) && ignore_auto_reply_event?(event)
+    return if auto_reply_event?(event, event_name)
 
     conversation = event.data[:conversation]
+    return unless conversation.inbox.active?
+
     account = conversation.account
     changed_attributes = event.data[:changed_attributes]
 
-    rules = conversation_rules(event_name, account)
-    return if rules.blank?
+    return unless rule_present?(event_name, account)
+
+    rules = current_account_rules(event_name, account)
 
     rules.each do |rule|
       conditions_match = ::AutomationRules::ConditionsFilterService.new(rule, conversation, { changed_attributes: changed_attributes }).perform
-      execute_rule(rule, account, conversation) if conditions_match.present?
-    end
-  end
-
-  # A delayed conversation rule reads as "the conversation has been in this status for N minutes",
-  # so a conversation created in that status must arm it too. Creation never dispatches
-  # CONVERSATION_UPDATED, and both paths key the episode on the same status_changed_at, so a later
-  # update arming the same episode is deduped by the unique index.
-  def conversation_rules(event_name, account)
-    rules = current_account_rules(event_name, account)
-    return rules unless event_name == 'conversation_created'
-
-    rules + current_account_rules('conversation_updated', account).where.not(execution_delay: nil)
-  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
+      AutomationRules::ActionService.new(rule, account, conversation).perform if conditions_match.present?
     end
   end
 
@@ -97,6 +76,10 @@ class AutomationRuleListener < BaseListener
     event.data[:performed_by].present? && event.data[:performed_by].instance_of?(AutomationRule)
   end
 
+  def auto_reply_event?(event, event_name)
+    %w[conversation_created conversation_opened].include?(event_name) && ignore_auto_reply_event?(event)
+  end
+
   def ignore_auto_reply_event?(event)
     conversation = event.data[:conversation]
     conversation.additional_attributes['auto_reply'].present?

app/listeners/csat_survey_listener.rb

@@ -3,6 +3,7 @@ class CsatSurveyListener < BaseListener
     conversation = extract_conversation_and_account(event)[0]
 
     return unless conversation.resolved?
+    return unless conversation.inbox.active?
 
     CsatSurveyService.new(conversation: conversation).perform
   end

app/mailboxes/reply_mailbox.rb

@@ -6,6 +6,7 @@ class ReplyMailbox < ApplicationMailbox
   def process
     # Return early if no conversation was found (e.g., notification emails, suspended accounts)
     return unless @conversation
+    return unless @conversation.inbox.active?
 
     # Wrap everything in a transaction to ensure atomicity
     # This prevents orphan conversations if message/attachment creation fails

app/models/account.rb

@@ -65,7 +65,6 @@ 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
@@ -112,7 +111,6 @@ 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
@@ -191,10 +189,6 @@ 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,17 +2,16 @@
 #
 # 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
-#  execution_delay :integer
-#  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
+#  name        :string           not null
+#  created_at  :datetime         not null
+#  updated_at  :datetime         not null
+#  account_id  :bigint           not null
 #
 # Indexes
 #
@@ -22,13 +21,7 @@ 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
@@ -36,13 +29,8 @@ 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) }
 
@@ -107,35 +95,6 @@ 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 + processing, the rows the sweep would otherwise still run. Rows already
-    # executing are left alone: their actions are in flight and cannot be called back.
-    pending_executions.armed.delete_all
-  end
-
   def validate_single_condition(condition)
     query_operator = condition['query_operator']
 

app/models/automation_rule_pending_execution.rb

@@ -1,204 +0,0 @@
-# == 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
-
-  # `processing` is claimed but not yet acting, so it is safe to reclaim and retry. `executing`
-  # means the actions are running: a row that dies there is never replayed, because the actions
-  # are customer-facing (messages, emails, webhooks) and repeating them is worse than dropping them.
-  enum status: { pending: 0, processing: 1, executed: 2, skipped: 3, executing: 4 }
-
-  # 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))
-  }
-
-  # Rows whose worker died mid-action. Nothing reclaims them; the sweep only counts them so a
-  # crash that strands customer-facing actions is visible instead of silent.
-  scope :abandoned, -> { executing.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)
-    # status_changed_at is only written from this feature onwards, so a conversation that predates it
-    # has no status clock. Anchoring on created_at would make every old conversation instantly
-    # overdue and fire on the next sweep; leave them for their next status change to arm.
-    return if message.nil? && conversation.status_changed_at.blank?
-
-    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
-
-    due_at = rule.execution_delay.minutes.since(anchor)
-    row = find_by!(automation_rule_id: rule.id, conversation_id: conversation.id, episode_key: key)
-    # The lock (and the reload it does) makes the compare-and-write atomic. Two listeners racing on
-    # the same episode would otherwise both read the old message_id and let whichever wrote last
-    # win, so an older message could overwrite a newer one and pull due_at backwards.
-    row.with_lock do
-      # 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.
-      next unless message.id > row.message_id
-
-      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.pending? || row.stale_processing?
-        # 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 whose 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
-  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
-    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)}"
-    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
-
-  # The claim renews updated_at, so a processing row past the timeout means its worker died. Only
-  # then may a re-arm take the row back: pulling a live worker's row to pending would let the sweep
-  # claim it and run the same actions alongside the worker still executing them.
-  def stale_processing?
-    processing? && updated_at < STALE_PROCESSING_TIMEOUT.ago
-  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) || stale_processing?
-  end
-end

app/models/campaign.rb

@@ -58,6 +58,7 @@ class Campaign < ApplicationRecord
   def trigger!
     return unless one_off?
     return unless feature_enabled?
+    return unless inbox.active?
     return unless mark_processing!
 
     execute_campaign

app/models/conversation.rb

@@ -15,7 +15,6 @@
 #  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
@@ -125,10 +124,8 @@ 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
 
@@ -275,10 +272,6 @@ 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/services/line/incoming_message_service.rb

@@ -7,6 +7,8 @@ class Line::IncomingMessageService
   LINE_STICKER_IMAGE_URL = 'https://stickershop.line-scdn.net/stickershop/v1/sticker/%s/android/sticker.png'.freeze
 
   def perform
+    return unless @inbox.active?
+
     # probably test events
     return if params[:events].blank?
 

app/services/mailbox/conversation_finder_strategies/new_conversation_strategy.rb

@@ -22,6 +22,7 @@ class Mailbox::ConversationFinderStrategies::NewConversationStrategy < Mailbox::
   # The actual persistence happens in ReplyMailbox within a transaction that includes message creation.
   def find
     return nil unless @channel # No valid channel found
+    return nil unless @inbox.active?
     return nil unless incoming_email_from_valid_email? # Skip edge cases
 
     # Check if conversation already exists by in_reply_to

app/services/sms/incoming_message_service.rb

@@ -4,6 +4,8 @@ class Sms::IncomingMessageService
   pattr_initialize [:inbox!, :params!]
 
   def perform
+    return unless @inbox.active?
+
     set_contact
     set_conversation
     @message = @conversation.messages.create!(

app/services/telegram/incoming_message_service.rb

@@ -7,6 +7,8 @@ class Telegram::IncomingMessageService
   pattr_initialize [:inbox!, :params!]
 
   def perform
+    return unless @inbox.active?
+
     # chatwoot doesn't support group conversations at the moment
     transform_business_message!
     return unless private_message?

app/services/tiktok/message_service.rb

@@ -4,6 +4,8 @@ class Tiktok::MessageService
   pattr_initialize [:channel!, :content!, :outgoing_echo]
 
   def perform
+    return unless channel.inbox.active?
+
     if outgoing_message?
       message = find_message(tt_conversation_id, tt_message_id)
       return if message.present?

app/services/twilio/incoming_message_service.rb

@@ -7,6 +7,7 @@ class Twilio::IncomingMessageService
 
   def perform
     return if twilio_channel.blank?
+    return unless inbox.active?
 
     set_contact
     set_conversation

app/services/twitter/direct_message_parser_service.rb

@@ -5,6 +5,8 @@ class Twitter::DirectMessageParserService < Twitter::WebhooksBaseService
     return if source_app_id == parent_app_id
 
     set_inbox
+    return unless @inbox.active?
+
     ensure_contacts
     set_conversation
     @message = @conversation.messages.create!(

app/services/twitter/tweet_parser_service.rb

@@ -4,6 +4,7 @@ class Twitter::TweetParserService < Twitter::WebhooksBaseService
   def perform
     set_inbox
 
+    return unless @inbox.active?
     return if !tweets_enabled? || message_already_exist? || user_has_blocked?
 
     create_message

app/services/whatsapp/incoming_message_base_service.rb

@@ -13,6 +13,8 @@ class Whatsapp::IncomingMessageBaseService
     if processed_params.try(:[], :statuses).present?
       process_statuses
     elsif messages_data.present?
+      return unless @inbox.active?
+
       process_messages
     end
   end

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

@@ -7,5 +7,4 @@ 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?

app/views/api/v1/models/_inbox.json.jbuilder

@@ -2,6 +2,7 @@ json.id resource.id
 json.avatar_url resource.try(:avatar_url)
 json.channel_id resource.channel_id
 json.name resource.name
+json.active resource.active
 json.channel_type resource.channel_type
 json.greeting_enabled resource.greeting_enabled
 json.greeting_message resource.greeting_message

config/features.yml

@@ -268,8 +268,3 @@
   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,10 +567,3 @@
   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

config/routes.rb

@@ -581,6 +581,12 @@ Rails.application.routes.draw do
             end
           end
           resources :email_channel_migrations, only: [:create]
+          resources :inboxes, only: [] do
+            member do
+              post :disable
+              post :enable
+            end
+          end
         end
       end
     end

db/migrate/20260609090000_add_active_to_inboxes.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class AddActiveToInboxes < ActiveRecord::Migration[7.0]
+  def change
+    add_column :inboxes, :active, :boolean, default: true, null: false
+  end
+end

db/migrate/20260709060000_add_execution_delay_to_automation_rules.rb

@@ -1,5 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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,24 +277,6 @@ 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
@@ -305,7 +287,6 @@ 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
 
@@ -807,7 +788,6 @@ 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"
@@ -1068,6 +1048,7 @@ ActiveRecord::Schema[7.1].define(version: 2026_07_13_184351) do
     t.boolean "enable_email_collect", default: true
     t.boolean "csat_survey_enabled", default: false
     t.boolean "allow_messages_after_resolved", default: true
+    t.boolean "active", default: true, null: false
     t.jsonb "auto_assignment_config", default: {}
     t.boolean "lock_to_single_conversation", default: false, null: false
     t.bigint "portal_id"

enterprise/app/controllers/api/v1/accounts/whatsapp_calls_controller.rb

@@ -1,6 +1,7 @@
 class Api::V1::Accounts::WhatsappCallsController < Api::V1::Accounts::BaseController
   before_action :set_call, only: %i[show accept reject terminate upload_recording]
   before_action :set_call_context, only: :initiate
+  before_action :ensure_inbox_active, only: :initiate
   before_action :ensure_calling_enabled, only: :initiate
   before_action :ensure_sdp_offer, only: :initiate
   before_action :ensure_contact_phone, only: :initiate
@@ -96,6 +97,10 @@ class Api::V1::Accounts::WhatsappCallsController < Api::V1::Accounts::BaseContro
     render_could_not_create_error(I18n.t('errors.whatsapp.calls.not_enabled'))
   end
 
+  def ensure_inbox_active
+    render_inbox_disabled_error unless @inbox.active?
+  end
+
   def ensure_sdp_offer
     return if params[:sdp_offer].present?
 

enterprise/app/controllers/enterprise/api/v1/accounts/agents_controller.rb

@@ -1,6 +1,8 @@
 module Enterprise::Api::V1::Accounts::AgentsController
   def create
     super
+    return if @agent.blank?
+
     associate_agent_with_custom_role
   end
 

enterprise/app/controllers/twilio/voice_controller.rb

@@ -90,10 +90,10 @@ class Twilio::VoiceController < ApplicationController
     from_number.start_with?('client:')
   end
 
-  # A fresh contact-initiated leg on an inbox with inbound calls turned off.
+  # A fresh contact-initiated leg on an inbox that cannot receive calls.
   # Reject it so no conference, conversation, or Call row is created.
   def reject_inbound?
-    twilio_direction == 'inbound' && !agent_leg?(twilio_from) && !inbox.channel.inbound_calls_enabled?
+    twilio_direction == 'inbound' && !agent_leg?(twilio_from) && (!inbox.active? || !inbox.channel.inbound_calls_enabled?)
   end
 
   def reject_twiml

enterprise/app/services/voice/outbound_call_builder.rb

@@ -16,6 +16,7 @@ class Voice::OutboundCallBuilder
   def perform!
     raise ArgumentError, 'Contact phone number required' if contact.phone_number.blank?
     raise ArgumentError, 'Agent required' if user.blank?
+    raise CustomExceptions::InboxDisabled unless inbox.active?
 
     # Claim for the caller if a reused conversation is unassigned at trigger time; wins over auto-assignment.
     # New conversations set the assignee at creation instead (see create_conversation!).

enterprise/app/services/whatsapp/incoming_call_service.rb

@@ -75,7 +75,7 @@ class Whatsapp::IncomingCallService
   end
 
   def create_inbound_call(payload)
-    unless inbox.channel.inbound_calls_enabled?
+    unless inbox.active? && inbox.channel.inbound_calls_enabled?
       Rails.logger.info "[WHATSAPP CALL] Inbound calls disabled for inbox #{inbox.id}; rejecting call #{payload[:id]}"
       inbox.channel.provider_service.reject_call(payload[:id])
       return

lib/custom_exceptions/inbox_disabled.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class CustomExceptions::InboxDisabled < CustomExceptions::Base
+  def initialize(data = {})
+    super
+  end
+
+  def message
+    'This inbox is currently disabled'
+  end
+
+  def error_code
+    'inbox_disabled'
+  end
+
+  def http_status
+    :forbidden
+  end
+end

spec/builders/agent_builder_spec.rb

@@ -23,6 +23,12 @@ RSpec.describe AgentBuilder, type: :model do
   end
 
   describe '#perform' do
+    it 'locks the account while checking and creating the agent' do
+      expect(account).to receive(:with_lock).and_call_original
+
+      agent_builder.perform
+    end
+
     context 'when user does not exist' do
       it 'creates a new user' do
         expect { agent_builder.perform }.to change(User, :count).by(1)
@@ -67,5 +73,17 @@ RSpec.describe AgentBuilder, type: :model do
         expect(user.encrypted_password).not_to be_empty
       end
     end
+
+    context 'when the account has reached its agent limit' do
+      before do
+        allow(account).to receive(:usage_limits).and_return({ agents: account.account_users.count })
+      end
+
+      it 'raises a limit exceeded error without creating a user' do
+        expect { agent_builder.perform }.to raise_error(described_class::LimitExceededError, described_class::LIMIT_EXCEEDED_MESSAGE)
+
+        expect(User.from_email(email)).to be_nil
+      end
+    end
   end
 end

spec/controllers/api/v1/accounts/integrations/linear_controller_spec.rb

@@ -13,7 +13,9 @@ RSpec.describe 'Linear Integration API', type: :request do
   end
 
   describe 'DELETE /api/v1/accounts/:account_id/integrations/linear' do
-    it 'deletes the linear integration' do
+    let(:admin) { create(:user, account: account, role: :administrator) }
+
+    it 'deletes the linear integration when the user is an administrator' do
       # Stub the HTTP call to Linear's revoke endpoint
       allow(HTTParty).to receive(:post).with(
         'https://api.linear.app/oauth/revoke',
@@ -21,11 +23,19 @@ RSpec.describe 'Linear Integration API', type: :request do
       ).and_return(instance_double(HTTParty::Response, success?: true))
 
       delete "/api/v1/accounts/#{account.id}/integrations/linear",
-             headers: agent.create_new_auth_token,
+             headers: admin.create_new_auth_token,
              as: :json
       expect(response).to have_http_status(:ok)
       expect(account.hooks.count).to eq(0)
     end
+
+    it 'returns unauthorized for an agent and keeps the integration' do
+      delete "/api/v1/accounts/#{account.id}/integrations/linear",
+             headers: agent.create_new_auth_token,
+             as: :json
+      expect(response).to have_http_status(:unauthorized)
+      expect(account.hooks.count).to eq(1)
+    end
   end
 
   describe 'GET /api/v1/accounts/:account_id/integrations/linear/teams' do

spec/controllers/api/v1/accounts/integrations/shopify_controller_spec.rb

@@ -159,15 +159,17 @@ RSpec.describe 'Shopify Integration API', type: :request do
   end
 
   describe 'DELETE /api/v1/accounts/:account_id/integrations/shopify' do
+    let(:admin) { create(:user, account: account, role: :administrator) }
+
     before do
       create(:integrations_hook, :shopify, account: account)
     end
 
-    context 'when it is an authenticated user' do
+    context 'when it is an administrator' do
       it 'deletes the shopify integration' do
         expect do
           delete "/api/v1/accounts/#{account.id}/integrations/shopify",
-                 headers: agent.create_new_auth_token,
+                 headers: admin.create_new_auth_token,
                  as: :json
         end.to change { account.hooks.count }.by(-1)
 
@@ -175,6 +177,18 @@ RSpec.describe 'Shopify Integration API', type: :request do
       end
     end
 
+    context 'when it is an agent' do
+      it 'returns unauthorized and keeps the integration' do
+        expect do
+          delete "/api/v1/accounts/#{account.id}/integrations/shopify",
+                 headers: agent.create_new_auth_token,
+                 as: :json
+        end.not_to(change { account.hooks.count })
+
+        expect(response).to have_http_status(:unauthorized)
+      end
+    end
+
     context 'when it is an unauthenticated user' do
       it 'returns unauthorized' do
         delete "/api/v1/accounts/#{account.id}/integrations/shopify",

spec/controllers/api/v1/widget/configs_controller_spec.rb

@@ -31,6 +31,18 @@ RSpec.describe '/api/v1/widget/config', type: :request do
         response_data = response.parsed_body
         expect(response_data.keys).to include(*response_keys)
       end
+
+      it 'does not initialize config or create a contact when the inbox is disabled' do
+        web_widget.inbox.update!(active: false)
+
+        expect do
+          post '/api/v1/widget/config',
+               params: params,
+               as: :json
+        end.not_to change(Contact, :count)
+
+        expect(response).to have_http_status(:forbidden)
+      end
     end
 
     context 'with correct website token and valid X-Auth-Token' do
@@ -48,6 +60,17 @@ RSpec.describe '/api/v1/widget/config', type: :request do
         expect(response_data['contact']['pubsub_token']).to eq(contact_inbox.pubsub_token)
       end
 
+      it 'does not initialize config when the inbox is disabled' do
+        web_widget.inbox.update!(active: false)
+
+        post '/api/v1/widget/config',
+             params: params,
+             headers: { 'X-Auth-Token' => token },
+             as: :json
+
+        expect(response).to have_http_status(:forbidden)
+      end
+
       it 'returns 401 if account is suspended' do
         account.update!(status: :suspended)
 

spec/controllers/api/v1/widget/contacts_controller_spec.rb

@@ -37,6 +37,18 @@ RSpec.describe '/api/v1/widget/contacts', type: :request do
         expect(ContactIdentifyAction).to have_received(:new).with(expected_params)
         expect(identify_action).to have_received(:perform)
       end
+
+      it 'does not update the contact when the inbox is disabled' do
+        web_widget.inbox.update!(active: false)
+
+        patch '/api/v1/widget/contact',
+              params: params,
+              headers: { 'X-Auth-Token' => token },
+              as: :json
+
+        expect(response).to have_http_status(:forbidden)
+        expect(ContactIdentifyAction).not_to have_received(:new)
+      end
     end
 
     context 'with update contact' do
@@ -255,6 +267,18 @@ RSpec.describe '/api/v1/widget/contacts', type: :request do
 
         expect(response).to have_http_status(:unauthorized)
       end
+
+      it 'does not set user when the inbox is disabled' do
+        web_widget.inbox.update!(active: false)
+
+        patch '/api/v1/widget/contact/set_user',
+              params: params.merge(identifier_hash: correct_identifier_hash),
+              headers: { 'X-Auth-Token' => token },
+              as: :json
+
+        expect(response).to have_http_status(:forbidden)
+        expect(ContactIdentifyAction).not_to have_received(:new)
+      end
     end
   end
 
@@ -263,19 +287,32 @@ RSpec.describe '/api/v1/widget/contacts', type: :request do
 
     context 'with invalid website token' do
       it 'returns unauthorized' do
-        post '/api/v1/widget/destroy_custom_attributes', params: { website_token: '' }
+        post '/api/v1/widget/contact/destroy_custom_attributes', params: { website_token: '' }
         expect(response).to have_http_status(:not_found)
       end
     end
 
     context 'with correct website token' do
       it 'calls destroy custom attributes' do
-        post '/api/v1/widget/destroy_custom_attributes',
+        post '/api/v1/widget/contact/destroy_custom_attributes',
              params: params,
              headers: { 'X-Auth-Token' => token },
              as: :json
         expect(contact.reload.custom_attributes).to eq({})
       end
+
+      it 'does not destroy custom attributes when the inbox is disabled' do
+        contact.update!(custom_attributes: { 'test' => 'value' })
+        web_widget.inbox.update!(active: false)
+
+        post '/api/v1/widget/contact/destroy_custom_attributes',
+             params: params,
+             headers: { 'X-Auth-Token' => token },
+             as: :json
+
+        expect(response).to have_http_status(:forbidden)
+        expect(contact.reload.custom_attributes).to eq('test' => 'value')
+      end
     end
   end
 end

spec/controllers/api/v1/widget/conversations_controller_spec.rb

@@ -43,6 +43,18 @@ RSpec.describe '/api/v1/widget/conversations/toggle_typing', type: :request do
         expect(json_response['id']).to eq(conversation.display_id)
         expect(json_response['status']).to eq(conversation.status)
       end
+
+      it 'returns the conversation when the inbox is disabled' do
+        web_widget.inbox.update!(active: false)
+
+        get '/api/v1/widget/conversations',
+            headers: { 'X-Auth-Token' => token },
+            params: { website_token: web_widget.website_token },
+            as: :json
+
+        expect(response).to have_http_status(:success)
+        expect(response.parsed_body['id']).to eq(conversation.display_id)
+      end
     end
 
     context 'with a conversation but invalid source id' do
@@ -62,6 +74,19 @@ RSpec.describe '/api/v1/widget/conversations/toggle_typing', type: :request do
   end
 
   describe 'POST /api/v1/widget/conversations' do
+    it 'does not create a conversation when the inbox is disabled' do
+      web_widget.inbox.update!(active: false)
+
+      expect do
+        post '/api/v1/widget/conversations',
+             headers: { 'X-Auth-Token' => token },
+             params: conversation_params,
+             as: :json
+      end.not_to change(Conversation, :count)
+
+      expect(response).to have_http_status(:forbidden)
+    end
+
     it 'creates a conversation with correct details' do
       post '/api/v1/widget/conversations',
            headers: { 'X-Auth-Token' => token },
@@ -244,11 +269,40 @@ RSpec.describe '/api/v1/widget/conversations/toggle_typing', type: :request do
 
         expect(conversation.reload.contact_last_seen_at).not_to be_nil
       end
+
+      it 'updates last seen when the inbox is disabled' do
+        current_time = DateTime.now.utc
+        allow(DateTime).to receive(:now).and_return(current_time)
+        web_widget.inbox.update!(active: false)
+
+        expect(Conversations::UpdateMessageStatusJob).to receive(:perform_later).with(conversation.id, current_time)
+
+        post '/api/v1/widget/conversations/update_last_seen',
+             headers: { 'X-Auth-Token' => token },
+             params: { website_token: web_widget.website_token },
+             as: :json
+
+        expect(response).to have_http_status(:success)
+        expect(conversation.reload.contact_last_seen_at).not_to be_nil
+      end
     end
   end
 
   describe 'POST /api/v1/widget/conversations/transcript' do
     context 'with a conversation' do
+      it 'does not send transcript email when the inbox is disabled' do
+        web_widget.inbox.update!(active: false)
+        contact.update!(email: 'test@test.com')
+        expect(ConversationReplyMailer).not_to receive(:with)
+
+        post '/api/v1/widget/conversations/transcript',
+             headers: { 'X-Auth-Token' => token },
+             params: { website_token: web_widget.website_token },
+             as: :json
+
+        expect(response).to have_http_status(:forbidden)
+      end
+
       it 'sends transcript email' do
         contact.update(email: 'test@test.com')
         mailer = double

spec/controllers/api/v1/widget/direct_uploads_controller_spec.rb

@@ -34,6 +34,24 @@ RSpec.describe '/api/v1/widget/direct_uploads', type: :request do
         json_response = response.parsed_body
         expect(json_response['content_type']).to eq('image/png')
       end
+
+      it 'does not create direct upload when the inbox is disabled' do
+        web_widget.inbox.update!(active: false)
+
+        post api_v1_widget_direct_uploads_url,
+             params: {
+               website_token: web_widget.website_token,
+               blob: {
+                 filename: 'avatar.png',
+                 byte_size: '1234',
+                 checksum: 'dsjbsdhbfif3874823mnsdbf',
+                 content_type: 'image/png'
+               }
+             },
+             headers: { 'X-Auth-Token' => token }
+
+        expect(response).to have_http_status(:forbidden)
+      end
     end
   end
 end

spec/controllers/api/v1/widget/events_controller_spec.rb

@@ -34,6 +34,20 @@ RSpec.describe '/api/v1/widget/events', type: :request do
           .with(params[:name], anything, contact_inbox: contact_inbox,
                                          event_info: { test_id: 'test', browser_language: nil, widget_language: nil, browser: anything })
       end
+
+      it 'does not dispatch events when the inbox is disabled' do
+        token
+        web_widget.inbox.update!(active: false)
+
+        expect(Rails.configuration.dispatcher).not_to receive(:dispatch)
+
+        post '/api/v1/widget/events',
+             params: params,
+             headers: { 'X-Auth-Token' => token },
+             as: :json
+
+        expect(response).to have_http_status(:forbidden)
+      end
     end
   end
 end