Merge branch 'develop' into fix/widget-conversations-throttle-key

Replaces the per-IP 6-per-12h throttle (disabled in cloud as too aggressive
for shared NAT IPs) with a per-(IP, website_token) 30-per-minute burst
throttle. Distinct widgets behind a shared NAT IP get separate buckets so
the original NAT pain is preserved while a single source can no longer
create unbounded conversations against one widget.

Adds ENABLE_RACK_ATTACK_WIDGET_CONVERSATIONS as an independent kill switch
so this throttle can be toggled without re-enabling the legacy widget
throttles. RATE_LIMIT_WIDGET_CONVERSATIONS controls the per-minute cap.

VERSION_CW

@@ -1 +1 @@
-4.14.1
+4.14.0

app/controllers/api/v1/accounts/microsoft/authorizations_controller.rb

@@ -6,7 +6,8 @@ class Api::V1::Accounts::Microsoft::AuthorizationsController < Api::V1::Accounts
       {
         redirect_uri: "#{base_url}/microsoft/callback",
         scope: scope,
-        state: state
+        state: state,
+        prompt: 'consent'
       }
     )
     if redirect_url

app/javascript/dashboard/components-next/call/CallCard.vue

@@ -35,14 +35,7 @@ const props = defineProps({
   },
 });
 
-defineEmits([
-  'accept',
-  'reject',
-  'end',
-  'toggleMute',
-  'goToConversation',
-  'dismiss',
-]);
+defineEmits(['accept', 'reject', 'end', 'toggleMute', 'goToConversation']);
 
 const { t } = useI18n();
 
@@ -122,19 +115,6 @@ const channelIcon = computed(() => {
           <span class="text-xs font-medium text-n-teal-9 tracking-tight">
             {{ statusLabel }}
           </span>
-          <!-- Dismiss: removes the notification from the UI without declining.
-               Incoming only — outgoing/ongoing calls are ended via the call
-               controls, not silently dismissed. -->
-          <NextButton
-            v-if="isIncoming"
-            v-tooltip.top="$t('CONVERSATION.VOICE_WIDGET.DISMISS_CALL')"
-            icon="i-ph-x-bold"
-            slate
-            ghost
-            xs
-            class="!rounded-full -my-1"
-            @click="$emit('dismiss')"
-          />
         </div>
       </div>
 

app/javascript/dashboard/components-next/call/FloatingCallWidget.vue

@@ -25,7 +25,6 @@ const {
   joinCall,
   endCall: endCallSession,
   rejectIncomingCall,
-  dismissCall,
   formattedCallDuration,
 } = useCallSession();
 
@@ -52,15 +51,6 @@ const mainCardState = computed(() => {
     : VOICE_CALL_DIRECTION.INCOMING;
 });
 
-// Stacked cards are always non-active (ringing) calls, so reflect each call's
-// real direction. An outbound call must render as OUTGOING — otherwise it shows
-// the incoming-only dismiss (✕) control and the agent could drop it locally
-// without terminating, leaving the customer ringing with no widget to end it.
-const stackedCardState = call =>
-  call?.callDirection === VOICE_CALL_DIRECTION.OUTBOUND
-    ? VOICE_CALL_DIRECTION.OUTGOING
-    : VOICE_CALL_DIRECTION.INCOMING;
-
 const toggleMute = () => {
   isMuted.value = !isMuted.value;
   setWhatsappCallMuted(isMuted.value);
@@ -240,11 +230,10 @@ onBeforeUnmount(stopRingtone);
       v-for="call in stackedIncomingCalls"
       :key="call.callSid"
       :call="call"
-      :state="stackedCardState(call)"
+      :state="VOICE_CALL_DIRECTION.INCOMING"
       :call-info="getCallInfo(call)"
       @accept="handleJoinCall(call)"
       @reject="rejectIncomingCall(call.callSid)"
-      @dismiss="dismissCall(call.callSid)"
       @go-to-conversation="goToConversation(call)"
     />
 
@@ -259,7 +248,6 @@ onBeforeUnmount(stopRingtone);
       :show-mute="hasActiveCall && isWhatsappActive"
       @accept="handleJoinCall(primaryIncomingCall)"
       @reject="rejectIncomingCall(primaryIncomingCall?.callSid)"
-      @dismiss="dismissCall(primaryIncomingCall?.callSid)"
       @end="handleEndCall"
       @toggle-mute="toggleMute"
       @go-to-conversation="goToConversation(activeCall || primaryIncomingCall)"

app/javascript/dashboard/components-next/captain/assistant/DocumentBulkActions.vue

@@ -25,7 +25,7 @@ const store = useStore();
 const bulkDeleteDialog = ref(null);
 
 const isSyncableDocument = doc =>
-  !doc.pdf_document && doc.status === 'available';
+  !doc.pdf_document && doc.status === 'available' && !doc.sync_in_progress;
 
 const syncableSelectedIds = computed(() => {
   if (!props.selectedIds.size) return [];

app/javascript/dashboard/components-next/captain/assistant/DocumentCard.vue

@@ -127,6 +127,7 @@ const menuItems = computed(() => {
       value: 'sync',
       action: 'sync',
       icon: 'i-lucide-refresh-cw',
+      disabled: props.syncInProgress,
     });
   }
 

app/javascript/dashboard/components-next/message/Message.vue

@@ -554,10 +554,11 @@ provideMessageContext({
         <Avatar v-bind="avatarInfo" :size="24" />
       </div>
       <div
-        class="[grid-area:bubble] flex min-w-0"
+        class="[grid-area:bubble] flex"
         :class="{
           'ltr:ml-8 rtl:mr-8 justify-end': orientation === ORIENTATION.RIGHT,
           'ltr:mr-8 rtl:ml-8': orientation === ORIENTATION.LEFT,
+          'min-w-0': variant === MESSAGE_VARIANTS.EMAIL,
         }"
         @contextmenu="openContextMenu($event)"
       >

app/javascript/dashboard/components-next/message/bubbles/Base.vue

@@ -95,7 +95,7 @@ const replyToPreview = computed(() => {
 
 <template>
   <div
-    class="text-sm min-w-0"
+    class="text-sm"
     :class="[
       messageClass,
       {

app/javascript/dashboard/components-next/message/bubbles/VoiceCall.vue

@@ -91,6 +91,10 @@ const wasDeclinedByAgent = computed(
     endReason.value === VOICE_CALL_END_REASON.AGENT_REJECTED
 );
 const acceptedByAgentId = computed(() => call.value?.acceptedByAgentId);
+const didCurrentUserAnswer = computed(
+  () =>
+    !!acceptedByAgentId.value && acceptedByAgentId.value === currentUserId.value
+);
 const conversationAssignee = computed(() => {
   const conversation = store.getters.getConversationById?.(
     conversationId?.value
@@ -120,48 +124,43 @@ const durationSeconds = computed(() => {
 
 const formattedDuration = computed(() => formatDuration(durationSeconds.value));
 
-// Agent who handled the call (initiator on outbound, answerer on inbound), taken
-// strictly from the persisted accept fields — never the conversation's current
-// assignee, which would mis-attribute a historical call after a reassignment.
-const handlerName = computed(() => {
-  if (call.value?.acceptedByAgentName) return call.value.acceptedByAgentName;
-  if (!acceptedByAgentId.value) return null;
-  const agent = store.getters['agents/getAgentById'](acceptedByAgentId.value);
-  return agent?.available_name || agent?.name || null;
-});
-
-const handledBy = computed(() =>
-  handlerName.value
-    ? t('CONVERSATION.VOICE_CALL.HANDLED_BY', { agentName: handlerName.value })
-    : null
-);
-
 const labelKey = computed(() => {
   if (LABEL_MAP[status.value]) return LABEL_MAP[status.value];
+  if (status.value === VOICE_CALL_STATUS.RINGING) {
+    return isOutbound.value
+      ? 'CONVERSATION.VOICE_CALL.OUTGOING_CALL'
+      : 'CONVERSATION.VOICE_CALL.INCOMING_CALL';
+  }
   if (isFailed.value) {
     return isOutbound.value
       ? 'CONVERSATION.VOICE_CALL.NO_ANSWER_OUTBOUND_LABEL'
       : 'CONVERSATION.VOICE_CALL.MISSED_CALL';
   }
-  // RINGING or an as-yet-unknown/initial status: orient purely by direction so an
-  // outbound call never falls through to the "Incoming call" label.
-  return isOutbound.value
-    ? 'CONVERSATION.VOICE_CALL.OUTGOING_CALL'
-    : 'CONVERSATION.VOICE_CALL.INCOMING_CALL';
+  return 'CONVERSATION.VOICE_CALL.INCOMING_CALL';
 });
 
 const subtext = computed(() => {
-  // Completed: "Handled by {agent} · 0:42" (drops either part when absent).
+  if (status.value === VOICE_CALL_STATUS.RINGING) {
+    return isOutbound.value
+      ? t('CONVERSATION.VOICE_CALL.CALLING')
+      : t('CONVERSATION.VOICE_CALL.NOT_ANSWERED_YET');
+  }
   if (status.value === VOICE_CALL_STATUS.COMPLETED) {
-    return [handledBy.value, formattedDuration.value]
-      .filter(Boolean)
-      .join(' · ');
+    return formattedDuration.value;
   }
   if (status.value === VOICE_CALL_STATUS.IN_PROGRESS) {
-    return handledBy.value;
+    if (isOutbound.value) return null;
+    if (didCurrentUserAnswer.value) {
+      return t('CONVERSATION.VOICE_CALL.YOU_ANSWERED');
+    }
+    if (displayAgentName.value) {
+      return t('CONVERSATION.VOICE_CALL.AGENT_ANSWERED', {
+        agentName: displayAgentName.value,
+      });
+    }
+    return null;
   }
   if (isFailed.value) {
-    // Missed/failed calls have no handler, so keep the reason rather than "Handled by".
     if (isOutbound.value) {
       return t('CONVERSATION.VOICE_CALL.NO_ANSWER_OUTBOUND_SUBTEXT');
     }
@@ -172,10 +171,6 @@ const subtext = computed(() => {
     }
     return t('CONVERSATION.VOICE_CALL.MISSED_CALL_INBOUND_SUBTEXT');
   }
-  // RINGING or an as-yet-unknown/initial status.
-  if (isOutbound.value) {
-    return handledBy.value || t('CONVERSATION.VOICE_CALL.CALLING');
-  }
   return t('CONVERSATION.VOICE_CALL.NOT_ANSWERED_YET');
 });
 

app/javascript/dashboard/components-next/message/chips/Audio.vue

@@ -31,17 +31,6 @@ const timeStampURL = computed(() => {
   return timeStampAppendedURL(attachment.dataUrl);
 });
 
-const TRANSCRIPT_PREVIEW_LENGTH = 200;
-const isTranscriptExpanded = ref(false);
-const isTranscriptLong = computed(
-  () => (attachment.transcribedText?.length || 0) > TRANSCRIPT_PREVIEW_LENGTH
-);
-const displayedTranscript = computed(() => {
-  const text = attachment.transcribedText || '';
-  if (!isTranscriptLong.value || isTranscriptExpanded.value) return text;
-  return `${text.slice(0, TRANSCRIPT_PREVIEW_LENGTH).trimEnd()}…`;
-});
-
 const audioPlayer = useTemplateRef('audioPlayer');
 
 const isPlaying = ref(false);
@@ -226,18 +215,7 @@ const downloadAudio = async () => {
       v-if="attachment.transcribedText && showTranscribedText"
       class="text-n-slate-12 p-3 text-sm bg-n-alpha-1 rounded-lg w-full break-words"
     >
-      {{ displayedTranscript }}
-      <button
-        v-if="isTranscriptLong"
-        class="block mt-1 p-0 border-0 bg-transparent text-n-slate-11 hover:text-n-slate-12 font-medium"
-        @click="isTranscriptExpanded = !isTranscriptExpanded"
-      >
-        {{
-          isTranscriptExpanded
-            ? $t('CONVERSATION.VOICE_CALL.TRANSCRIPT_SHOW_LESS')
-            : $t('CONVERSATION.VOICE_CALL.TRANSCRIPT_SHOW_MORE')
-        }}
-      </button>
+      {{ attachment.transcribedText }}
     </div>
   </div>
 </template>

app/javascript/dashboard/helper/voice.js

@@ -1,5 +1,4 @@
 import { CONTENT_TYPES } from 'dashboard/components-next/message/constants';
-import { MESSAGE_TYPE } from 'shared/constants/messages';
 import { useCallsStore } from 'dashboard/stores/calls';
 import types from 'dashboard/store/mutation-types';
 
@@ -59,10 +58,6 @@ function extractCallerSnapshot(message) {
   // Snapshot caller info from the message at add-time so the widget can keep
   // rendering it after the user navigates away from a conversation list that
   // had the conversation hydrated (and Vuex evicts it from the store).
-  // Only incoming messages carry the contact as the sender; on outbound calls
-  // the sender is the initiating agent, so skip the snapshot and let the widget
-  // fall back to the conversation's contact (conversation.meta.sender).
-  if (message?.message_type !== MESSAGE_TYPE.INCOMING) return null;
   const sender = message?.sender;
   if (!sender) return null;
   return {

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

@@ -86,16 +86,13 @@
       "MISSED_CALL_INBOUND_SUBTEXT": "No agent picked up",
       "MISSED_CALL_DECLINED_BY": "Declined by {agentName}",
       "CALL_ENDED": "Call ended",
-      "HANDLED_BY": "Handled by {agentName}",
       "NOT_ANSWERED_YET": "Not answered yet",
       "CALLING": "Calling…",
       "THEY_ANSWERED": "They answered",
       "YOU_ANSWERED": "You answered",
       "AGENT_ANSWERED": "{agentName} answered",
       "JOIN_CALL": "Join call",
-      "CALL_BACK": "Call back",
-      "TRANSCRIPT_SHOW_MORE": "Show more",
-      "TRANSCRIPT_SHOW_LESS": "Show less"
+      "CALL_BACK": "Call back"
     },
     "HEADER": {
       "RESOLVE_ACTION": "Resolve",
@@ -315,7 +312,6 @@
       "NOT_ANSWERED_YET": "Not answered yet",
       "HANDLED_IN_ANOTHER_TAB": "Being handled in another tab",
       "REJECT_CALL": "Reject",
-      "DISMISS_CALL": "Dismiss",
       "JOIN_CALL": "Join call",
       "END_CALL": "End call",
       "MUTE": "Mute mic",

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

@@ -253,6 +253,7 @@ export default {
 
       if (
         this.isAWhatsAppCloudChannel &&
+        this.isEmbeddedSignupWhatsApp &&
         this.isFeatureEnabledonAccount(
           this.accountId,
           FEATURE_FLAGS.CHANNEL_VOICE

app/javascript/dashboard/store/modules/auditlogs.js

@@ -7,7 +7,7 @@ const state = {
   records: [],
   meta: {
     currentPage: 1,
-    perPage: 25,
+    perPage: 15,
     totalEntries: 0,
   },
   uiFlags: {

app/javascript/dashboard/stores/calls.js

@@ -54,9 +54,7 @@ export const useCallsStore = defineStore('calls', {
         return;
       }
 
-      // Prepend so the newest call surfaces as the primary card (incomingCalls[0])
-      // and older calls drop into the stack below it.
-      this.calls.unshift({
+      this.calls.push({
         ...callData,
         isActive: false,
       });

app/jobs/internal/trigger_daily_scheduled_items_job.rb

@@ -23,5 +23,3 @@ class Internal::TriggerDailyScheduledItemsJob < ApplicationJob
     @designated_minute ||= Digest::MD5.hexdigest(ChatwootHub.installation_identifier).hex % 1440
   end
 end
-
-Internal::TriggerDailyScheduledItemsJob.prepend_mod_with('Internal::TriggerDailyScheduledItemsJob')

app/models/channel/whatsapp.rb

@@ -41,19 +41,19 @@ class Channel::Whatsapp < ApplicationRecord
   end
 
   # Mirrors Channel::TwilioSms#voice_enabled? so the call subsystem can duck-type across providers.
-  # Meta's Calling API is available to any whatsapp_cloud inbox (embedded-signup or manual keys);
-  # only 360dialog (default provider) can't reach the call APIs.
+  # Meta's Calling API is only available via the embedded-signup whatsapp_cloud flow —
+  # 360dialog (default provider) and manual whatsapp_cloud setups can't reach the call APIs.
   def voice_enabled?
     voice_calling_supported? &&
       provider_config['calling_enabled'].present? &&
       account.feature_enabled?('channel_voice')
   end
 
-  # Whether this inbox can do WhatsApp calling at all. Meta's Calling API is
-  # reachable by any whatsapp_cloud inbox, so 360dialog inboxes can't be toggled
-  # on even though calling_enabled would persist.
+  # Whether this inbox can do WhatsApp calling at all. Meta's Calling API is only
+  # reachable via the embedded-signup whatsapp_cloud flow, so manual whatsapp_cloud
+  # and 360dialog inboxes can't be toggled on even though calling_enabled would persist.
   def voice_calling_supported?
-    provider == 'whatsapp_cloud'
+    provider == 'whatsapp_cloud' && provider_config['source'] == 'embedded_signup'
   end
 
   def provider_service
@@ -69,7 +69,7 @@ class Channel::Whatsapp < ApplicationRecord
   # Saved with validate: false to skip validate_provider_config's remote credential
   # re-check, which could spuriously fail and desync the flag from Meta.
   def enable_voice_calling!
-    raise 'WhatsApp calling requires a whatsapp_cloud inbox' unless voice_calling_supported?
+    raise 'WhatsApp calling requires an embedded-signup whatsapp_cloud inbox' unless voice_calling_supported?
     raise 'WhatsApp calling requires the channel_voice feature' unless account.feature_enabled?('channel_voice')
 
     provider_service.update_calling_status('ENABLED')
@@ -82,7 +82,7 @@ class Channel::Whatsapp < ApplicationRecord
   # `calls` from the webhook subscription (best-effort, so a Meta outage can't
   # trap admins). Leaves Meta's WABA calling.status untouched.
   def disable_voice_calling!
-    raise 'WhatsApp calling requires a whatsapp_cloud inbox' unless voice_calling_supported?
+    raise 'WhatsApp calling requires an embedded-signup whatsapp_cloud inbox' unless voice_calling_supported?
 
     self.provider_config = provider_config.merge('calling_enabled' => false)
     save!(validate: false)

app/services/website_branding_service.rb

@@ -1,5 +1,3 @@
-require 'resolv'
-
 class WebsiteBrandingService
   include SocialLinkParser
 
@@ -26,8 +24,7 @@ class WebsiteBrandingService
                           colors: extract_colors(doc),
                           logos: extract_logos(doc),
                           socials: build_socials(links),
-                          email: @email,
-                          email_provider: detect_email_provider
+                          email: @email
                         })
   rescue StandardError => e
     Rails.logger.error "[WebsiteBranding] #{e.message}"
@@ -107,37 +104,6 @@ class WebsiteBrandingService
   rescue URI::InvalidURIError
     nil
   end
-
-  GOOGLE_MX_DOMAINS = %w[google.com googlemail.com].freeze
-  MICROSOFT_MX_DOMAINS = %w[outlook.com].freeze
-
-  # Probes the domain's MX records to infer the mailbox provider, returning
-  # 'google' or 'microsoft' (matching Channel::Email#provider) or nil when unknown.
-  def detect_email_provider
-    hosts = mx_records
-    return 'google' if mx_hosted_by?(hosts, GOOGLE_MX_DOMAINS)
-    return 'microsoft' if mx_hosted_by?(hosts, MICROSOFT_MX_DOMAINS)
-
-    nil
-  end
-
-  # Matches on the registrable domain of the MX host (anchored on a label
-  # boundary) so lookalikes like "notgoogle.com" don't get misclassified.
-  def mx_hosted_by?(hosts, provider_domains)
-    hosts.any? do |host|
-      provider_domains.any? { |domain| host == domain || host.end_with?(".#{domain}") }
-    end
-  end
-
-  def mx_records
-    Resolv::DNS.open do |resolver|
-      resolver.timeouts = 5
-      resolver.getresources(@domain, Resolv::DNS::Resource::IN::MX).map { |record| record.exchange.to_s.downcase }
-    end
-  rescue StandardError => e
-    Rails.logger.error "[WebsiteBranding] MX probe failed for #{@domain}: #{e.message}"
-    []
-  end
 end
 
 WebsiteBrandingService.prepend_mod_with('WebsiteBrandingService')

config/app.yml

@@ -1,5 +1,5 @@
 shared: &shared
-  version: '4.14.1'
+  version: '4.14.0'
 
 development:
   <<: *shared

config/initializers/rack_attack.rb

@@ -170,15 +170,25 @@ class Rack::Attack
   ###-----------Widget API Throttling---------------###
   ###-----------------------------------------------###
 
+  ## Burst protection on widget conversation creation. Keyed on (IP, website_token)
+  ## so distinct widgets behind a shared NAT IP get separate buckets. Independent
+  ## kill switch so it can be toggled without touching the legacy ENABLE_RACK_ATTACK_WIDGET_API.
+  if ActiveModel::Type::Boolean.new.cast(ENV.fetch('ENABLE_RACK_ATTACK_WIDGET_CONVERSATIONS', true))
+    throttle('api/v1/widget/conversations',
+             limit: ENV.fetch('RATE_LIMIT_WIDGET_CONVERSATIONS', '30').to_i,
+             period: 1.minute) do |req|
+      next unless req.path_without_extentions == '/api/v1/widget/conversations' && req.post?
+
+      token = req.params['website_token'].presence ||
+              ActionDispatch::Request.new(req.env).params['website_token'].presence
+      "#{req.ip}:#{token}" if token
+    end
+  end
+
   # Rack attack on widget APIs can be disabled by setting ENABLE_RACK_ATTACK_WIDGET_API to false
   # For clients using the widgets in specific conditions like inside and iframe
   # TODO: Deprecate this feature in future after finding a better solution
   if ActiveModel::Type::Boolean.new.cast(ENV.fetch('ENABLE_RACK_ATTACK_WIDGET_API', true))
-    ## Prevent Conversation Bombing on Widget APIs ###
-    throttle('api/v1/widget/conversations', limit: 6, period: 12.hours) do |req|
-      req.ip if req.path_without_extentions == '/api/v1/widget/conversations' && req.post?
-    end
-
     ## Prevent Contact update Bombing in Widget API ###
     throttle('api/v1/widget/contacts', limit: 60, period: 1.hour) do |req|
       req.ip if req.path_without_extentions == '/api/v1/widget/contacts' && (req.patch? || req.put?)

config/installation_config.yml

@@ -215,18 +215,6 @@
   value:
   locked: false
   type: code
-- name: CAPTAIN_DOCUMENT_AUTO_SYNC_PER_ACCOUNT_BATCH_LIMIT
-  display_title: 'Captain Document Auto Sync Per Account Batch Limit'
-  description: 'Maximum syncable Captain documents to enqueue per account in one scheduler run. Defaults to 50.'
-  value: 50
-  locked: false
-  type: number
-- name: CAPTAIN_DOCUMENT_AUTO_SYNC_GLOBAL_BATCH_LIMIT
-  display_title: 'Captain Document Auto Sync Global Batch Limit'
-  description: 'Maximum syncable Captain documents to enqueue globally in one scheduler run. Defaults to 1000.'
-  value: 1000
-  locked: false
-  type: number
 # End of Captain Config
 
 # ------- Context.dev Config ------- #

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

@@ -2,7 +2,7 @@ class Api::V1::Accounts::AuditLogsController < Api::V1::Accounts::EnterpriseAcco
   before_action :check_admin_authorization?
   before_action :fetch_audit
 
-  RESULTS_PER_PAGE = 25
+  RESULTS_PER_PAGE = 15
 
   def show
     @audit_logs = @audit_logs.page(params[:page]).per(RESULTS_PER_PAGE)

enterprise/app/controllers/api/v1/accounts/captain/bulk_actions_controller.rb

@@ -75,6 +75,7 @@ class Api::V1::Accounts::Captain::BulkActionsController < Api::V1::Accounts::Bas
     Current.account.captain_documents.where(id: params[:ids]).find_each(batch_size: 100) do |document|
       next unless document.syncable?
       next unless document.available?
+      next if document.sync_in_progress?
 
       document.update!(
         sync_status: :syncing,

enterprise/app/controllers/api/v1/accounts/captain/documents_controller.rb

@@ -37,6 +37,7 @@ class Api::V1::Accounts::Captain::DocumentsController < Api::V1::Accounts::BaseC
   def sync
     return render_could_not_create_error(I18n.t('captain.documents.sync_not_supported_for_pdf')) unless @document.syncable?
     return render_could_not_create_error(I18n.t('captain.documents.sync_only_available_documents')) unless @document.available?
+    return render_could_not_create_error(I18n.t('captain.documents.sync_already_in_progress')) if @document.sync_in_progress?
 
     @document.update!(
       sync_status: :syncing,

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

@@ -35,14 +35,8 @@ class Api::V1::Accounts::WhatsappCallsController < Api::V1::Accounts::BaseContro
 
   def initiate
     @call = create_outbound_call
-    # Link the call to its message in one transaction so the message.created
-    # broadcast (an after_create_commit hook) fires only once call.message_id is
-    # set. Otherwise the live ringing bubble receives a message with no `call`
-    # payload (no direction/agent) and renders "Calling…" instead of "Handled by …".
-    ActiveRecord::Base.transaction do
-      @message = Voice::CallMessageBuilder.new(@call).perform!
-      @call.update!(message_id: @message.id)
-    end
+    @message = Voice::CallMessageBuilder.new(@call).perform!
+    @call.update!(message_id: @message.id)
   end
 
   private

enterprise/app/jobs/captain/documents/perform_sync_job.rb

@@ -48,7 +48,9 @@ class Captain::Documents::PerformSyncJob < MutexApplicationJob
     return if document.pdf_document?
 
     with_lock(lock_key(document), LOCK_TIMEOUT) do
-      perform_sync(document, start_time)
+      mark_sync_started(document)
+      result = Captain::Documents::SyncService.new(document.reload).perform
+      log_sync_outcome(document, result: result, duration_ms: duration_ms_since(start_time))
     end
   rescue LockAcquisitionError
     log_sync_outcome(document, result: :already_syncing)
@@ -62,12 +64,6 @@ class Captain::Documents::PerformSyncJob < MutexApplicationJob
 
   private
 
-  def perform_sync(document, start_time)
-    mark_sync_started(document)
-    result = Captain::Documents::SyncService.new(document.reload).perform
-    log_sync_outcome(document, result: result, duration_ms: duration_ms_since(start_time))
-  end
-
   def log_sync_outcome(document, **fields)
     payload = {
       document_id: document.id,

enterprise/app/jobs/captain/documents/schedule_syncs_job.rb

@@ -1,27 +1,21 @@
 class Captain::Documents::ScheduleSyncsJob < ApplicationJob
   queue_as :scheduled_jobs
 
-  DEFAULT_PER_ACCOUNT_BATCH_LIMIT = 50
-  DEFAULT_GLOBAL_BATCH_LIMIT = 1000
+  PER_ACCOUNT_HOURLY_CAP = 50
+  GLOBAL_HOURLY_CAP = 1000
+  DUE_DOCUMENT_BATCH_SIZE = PER_ACCOUNT_HOURLY_CAP * 2 # Inspite of skipping, we should at least reach the hourly cap
   SYNC_STALE_TIMEOUT = Captain::Document::SYNC_STALE_TIMEOUT
-  DAILY_SYNC_JITTER = 4.hours
-  WEEKLY_SYNC_JITTER = 1.day
-  MONTHLY_SYNC_JITTER = 4.days
 
-  def perform(plan_name = nil)
-    @per_account_batch_limit = configured_sync_limit('CAPTAIN_DOCUMENT_AUTO_SYNC_PER_ACCOUNT_BATCH_LIMIT', DEFAULT_PER_ACCOUNT_BATCH_LIMIT)
-    @global_batch_limit = configured_sync_limit('CAPTAIN_DOCUMENT_AUTO_SYNC_GLOBAL_BATCH_LIMIT', DEFAULT_GLOBAL_BATCH_LIMIT)
-    @remaining_global_capacity = @global_batch_limit
-    @plan_name = plan_name.to_s.downcase.presence
+  def perform
+    @remaining_global_capacity = GLOBAL_HOURLY_CAP
     sync_intervals = Enterprise::Account.captain_document_sync_intervals
-    stats = { accounts_scanned: 0, accounts_enabled: 0, accounts_scheduled: 0, documents_enqueued: 0 }
+    stats = { accounts_scanned: 0, accounts_enabled: 0, accounts_scheduled: 0, documents_enqueued: 0, documents_skipped: 0 }
 
     Account.joins(:captain_documents).distinct.find_each(batch_size: 100) do |account|
       break if @remaining_global_capacity <= 0
 
       stats[:accounts_scanned] += 1
       next unless account.feature_enabled?('captain_document_auto_sync')
-      next unless account_in_selected_plan?(account)
 
       stats[:accounts_enabled] += 1
       interval = account.captain_document_sync_interval(sync_intervals)
@@ -30,6 +24,7 @@ class Captain::Documents::ScheduleSyncsJob < ApplicationJob
       stats[:accounts_scheduled] += 1
       result = enqueue_due_documents(account, interval)
       stats[:documents_enqueued] += result[:enqueued]
+      stats[:documents_skipped] += result[:skipped]
     end
 
     log_scheduler_summary(stats)
@@ -38,85 +33,92 @@ class Captain::Documents::ScheduleSyncsJob < ApplicationJob
   private
 
   def enqueue_due_documents(account, interval)
-    per_account_limit = [@per_account_batch_limit, @remaining_global_capacity].min
-    result = { enqueued: 0 }
+    per_account_limit = [PER_ACCOUNT_HOURLY_CAP, @remaining_global_capacity].min
+    result = { enqueued: 0, skipped: 0 }
+    skipped_document_ids = []
 
-    due_documents(account, interval).limit(per_account_limit).to_a.each do |document|
-      process_due_document(document, interval, result)
+    while result[:enqueued] < per_account_limit
+
+      documents = due_documents(account, interval, skipped_document_ids).limit(DUE_DOCUMENT_BATCH_SIZE).to_a
+      break if documents.empty?
+
+      documents.each do |document|
+        break if result[:enqueued] >= per_account_limit
+
+        process_due_document(document, result, skipped_document_ids)
+      end
     end
 
     result
   end
 
-  def process_due_document(document, interval, result)
-    sync_execution_delay = sync_jitter(interval)
+  def process_due_document(document, result, skipped_document_ids)
+    return unless document.syncable?
 
-    Captain::Documents::PerformSyncJob.set(queue: :purgable, wait: sync_execution_delay).perform_later(document)
+    # Reserve the sync slot before enqueueing so later scheduler runs skip this document while the job is queued.
+    unless reserve_sync_slot(document)
+      result[:skipped] += 1
+      skipped_document_ids << document.id
+      return
+    end
+
+    Captain::Documents::PerformSyncJob.perform_later(document)
     @remaining_global_capacity -= 1
     result[:enqueued] += 1
   end
 
-  def due_documents(account, interval)
+  def due_documents(account, interval, skipped_document_ids)
     syncing = Captain::Document.sync_statuses[:syncing]
     synced = Captain::Document.sync_statuses[:synced]
     failed = Captain::Document.sync_statuses[:failed]
-    stale_cutoff = SYNC_STALE_TIMEOUT.ago
-    # The scheduler runs at predictable plan windows. Use a wider due window so
-    # jittered executions do not miss the next window just because they finished later.
-    sync_due_before = due_window(interval).ago
 
     documents = account.captain_documents.syncable.where(status: :available).where(
       '(sync_status = ? AND last_synced_at < ?) OR (sync_status = ? AND last_sync_attempted_at < ?) OR ' \
       '(sync_status = ? AND last_sync_attempted_at < ?)',
-      synced, sync_due_before, failed, sync_due_before, syncing, stale_cutoff
+      synced, interval.ago, failed, interval.ago, syncing, SYNC_STALE_TIMEOUT.ago
     )
+    documents = documents.where.not(id: skipped_document_ids) if skipped_document_ids.present?
     documents.order(Arel.sql('last_sync_attempted_at ASC NULLS FIRST'), :id)
   end
 
-  def configured_sync_limit(config_key, default)
-    configured_value = InstallationConfig.find_by(name: config_key)&.value
-    limit = configured_value.to_s.to_i
-    limit.positive? ? limit : default
+  def reserve_sync_slot(document)
+    mark_sync_started(document)
+    true
+  rescue ActiveRecord::RecordInvalid => e
+    log_document_skip(document, e)
+    false
   end
 
-  def account_in_selected_plan?(account)
-    return true if @plan_name.blank?
+  def log_document_skip(document, error)
+    payload = {
+      event: 'document_skipped',
+      document_id: document.id,
+      account_id: document.account_id,
+      assistant_id: document.assistant_id,
+      error_class: error.class.name,
+      error_message: error.message,
+      validation_errors: document.errors.full_messages
+    }
 
-    account_sync_plan(account) == @plan_name
-  end
-
-  def account_sync_plan(account)
-    plan = account.custom_attributes['plan_name']
-    plan = 'enterprise' if plan.blank? && ChatwootApp.self_hosted_enterprise?
-    plan.to_s.downcase.presence
-  end
-
-  def sync_jitter(interval)
-    jitter_window = if interval <= 1.day
-                      DAILY_SYNC_JITTER
-                    elsif interval <= 1.week
-                      WEEKLY_SYNC_JITTER
-                    else
-                      MONTHLY_SYNC_JITTER
-                    end
-
-    rand(0..jitter_window.to_i).seconds
-  end
-
-  def due_window(interval)
-    (interval.to_i / 2).seconds
+    Rails.logger.warn("[Captain::Documents::ScheduleSyncsJob] #{payload.to_json}")
   end
 
   def log_scheduler_summary(stats)
     payload = {
       event: 'completed',
-      plan_name: @plan_name,
       global_cap_hit: @remaining_global_capacity <= 0,
-      per_account_batch_limit: @per_account_batch_limit,
-      global_batch_limit: @global_batch_limit,
       remaining_global_capacity: @remaining_global_capacity
     }.merge(stats)
 
     Rails.logger.info("[Captain::Documents::ScheduleSyncsJob] #{payload.to_json}")
   end
+
+  def mark_sync_started(document)
+    document.update!(
+      sync_status: :syncing,
+      sync_step: nil,
+      last_sync_error_code: nil,
+      last_sync_attempted_at: Time.current
+    )
+  end
 end

enterprise/app/jobs/enterprise/internal/trigger_daily_scheduled_items_job.rb

@@ -1,19 +0,0 @@
-module Enterprise::Internal::TriggerDailyScheduledItemsJob
-  def perform
-    super
-
-    Captain::Documents::ScheduleSyncsJob.perform_later('enterprise')
-    Captain::Documents::ScheduleSyncsJob.perform_later('business') if business_auto_sync_due?
-    Captain::Documents::ScheduleSyncsJob.perform_later('startups') if startup_auto_sync_due?
-  end
-
-  private
-
-  def business_auto_sync_due?
-    Time.current.utc.sunday?
-  end
-
-  def startup_auto_sync_due?
-    Time.current.utc.day == 1
-  end
-end

enterprise/app/jobs/enterprise/internal/trigger_hourly_scheduled_items_job.rb

@@ -0,0 +1,7 @@
+module Enterprise::Internal::TriggerHourlyScheduledItemsJob
+  def perform
+    super
+
+    Captain::Documents::ScheduleSyncsJob.perform_later
+  end
+end

enterprise/app/jobs/enterprise/webhooks/whatsapp_events_job.rb

@@ -31,11 +31,10 @@ module Enterprise::Webhooks::WhatsappEventsJob
   #     and timer/recorder kick off before the contact actually answers.
   def handle_call_events(channel, params)
     value = params.dig(:entry, 0, :changes, 0, :value) || {}
-    contacts = value[:contacts]
 
     Array(value[:calls]).each do |call_payload|
       with_call_lock(channel, call_payload[:id]) do
-        Whatsapp::IncomingCallService.new(inbox: channel.inbox, params: { calls: [call_payload], contacts: contacts }).perform
+        Whatsapp::IncomingCallService.new(inbox: channel.inbox, params: { calls: [call_payload] }).perform
       end
     end
 

enterprise/app/services/enterprise/billing/reconcile_plan_features_service.rb

@@ -16,7 +16,6 @@ class Enterprise::Billing::ReconcilePlanFeaturesService
     advanced_search_indexing
     advanced_search
     linear_integration
-    channel_voice
   ].freeze
 
   BUSINESS_PLAN_FEATURES = %w[sla custom_roles csat_review_notes conversation_required_attributes advanced_assignment custom_tools].freeze

enterprise/app/services/enterprise/website_branding_service.rb

@@ -58,7 +58,6 @@ module Enterprise::WebsiteBrandingService
       socials: brand['socials'] || [],
       links: brand['links'],
       email: @email,
-      email_provider: detect_email_provider,
       industries: brand.dig('industries', 'eic') || [],
       stock: brand['stock'],
       is_nsfw: brand['is_nsfw'] || false

enterprise/app/services/messages/audio_transcription_service.rb

@@ -1,12 +1,11 @@
 class Messages::AudioTranscriptionService< Llm::LegacyBaseOpenAiService
   include Integrations::LlmInstrumentation
 
-  TRANSCRIPTION_MODEL = 'gpt-4o-mini-transcribe'.freeze
-  # OpenAI's transcription endpoint hard limit is 25 MB *decimal* (25_000_000), not
-  # binary (25.megabytes = 26_214_400) — using the binary form leaks the 25.0–26.2 MB
-  # range to the API as 413s. Long audio (~70+ min Opus) keeps the attachment but skips
-  # transcription.
-  TRANSCRIPTION_BYTE_LIMIT = 25_000_000
+  WHISPER_MODEL = 'whisper-1'.freeze
+  # Whisper's hard limit is 25 MB *decimal* (25_000_000), not binary (25.megabytes
+  # = 26_214_400) — using the binary form leaks the 25.0–26.2 MB range to the API
+  # as 413s. Long audio (~70+ min Opus) keeps the attachment but skips transcription.
+  WHISPER_BYTE_LIMIT = 25_000_000
 
   attr_reader :attachment, :message, :account
 
@@ -43,7 +42,7 @@ class Messages::AudioTranscriptionService< Llm::LegacyBaseOpenAiService
     blob = attachment.file&.blob
     return false unless blob
 
-    blob.byte_size > TRANSCRIPTION_BYTE_LIMIT
+    blob.byte_size > WHISPER_BYTE_LIMIT
   end
 
   def fetch_audio_file
@@ -76,12 +75,12 @@ class Messages::AudioTranscriptionService< Llm::LegacyBaseOpenAiService
     transcribed_text = nil
 
     File.open(temp_file_path, 'rb') do |file|
-      # temperature: 0.0 minimises hallucinations on silence / near-silent
-      # audio; non-zero values trigger spiraling repeats — well-documented
-      # behaviour across OpenAI transcription models.
+      # temperature: 0.0 minimises Whisper's hallucinations on silence /
+      # near-silent audio; non-zero values trigger spiraling repeats like
+      # "Oh, dear. Oh, dear. Oh, dear." — well-documented Whisper behaviour.
       response = @client.audio.transcribe(
         parameters: {
-          model: TRANSCRIPTION_MODEL,
+          model: WHISPER_MODEL,
           file: file,
           temperature: 0.0
         }
@@ -98,7 +97,7 @@ class Messages::AudioTranscriptionService< Llm::LegacyBaseOpenAiService
   def instrumentation_params(file_path)
     {
       span_name: 'llm.messages.audio_transcription',
-      model: TRANSCRIPTION_MODEL,
+      model: WHISPER_MODEL,
       account_id: account&.id,
       feature_name: 'audio_transcription',
       file_path: file_path

enterprise/app/services/voice/inbound_call_builder.rb

@@ -59,17 +59,9 @@ class Voice::InboundCallBuilder
   end
 
   def ensure_contact!
-    contact = account.contacts.find_or_create_by!(phone_number: from_number) do |record|
-      record.name = contact_name.presence || from_number
+    account.contacts.find_or_create_by!(phone_number: from_number) do |record|
+      record.name = from_number if record.name.blank?
     end
-    contact.update!(name: contact_name) if contact_name.present? && contact.name == from_number
-    contact
-  end
-
-  # WhatsApp inbound calls carry the caller's profile name in extra_meta; Twilio
-  # calls don't, so contact naming falls back to the phone number.
-  def contact_name
-    extra_meta['contact_name'].presence
   end
 
   # WhatsApp ContactInbox.source_id must be digits-only (the wa_id); Twilio accepts the +.

enterprise/app/services/whatsapp/incoming_call_service.rb

@@ -73,27 +73,15 @@ class Whatsapp::IncomingCallService
 
   def create_inbound_call(payload)
     sdp_offer = payload.dig(:session, :sdp)
-    extra_meta = { 'sdp_offer' => sdp_offer, 'ice_servers' => Call.default_ice_servers }
-    name = caller_profile_name(payload)
-    extra_meta['contact_name'] = name if name.present?
-
     call = Voice::InboundCallBuilder.perform!(
       inbox: inbox, from_number: "+#{payload[:from]}", call_sid: payload[:id],
-      provider: :whatsapp, extra_meta: extra_meta
+      provider: :whatsapp,
+      extra_meta: { 'sdp_offer' => sdp_offer, 'ice_servers' => Call.default_ice_servers }
     )
     update_conversation(call)
     broadcast_incoming(call, sdp_offer)
   end
 
-  # Match strictly on wa_id (== calls[].from): in a batched payload missing this
-  # call's contact entry, borrowing another caller's name would corrupt this
-  # contact, so fall back to the phone number (nil here) instead of contacts.first.
-  def caller_profile_name(payload)
-    contacts = Array(params[:contacts]).map(&:with_indifferent_access)
-    match = contacts.find { |c| c[:wa_id].to_s == payload[:from].to_s }
-    match&.dig(:profile, :name).presence
-  end
-
   # `connect` is the WebRTC tunnel-ready signal, not the pickup signal. Apply
   # Meta's SDP answer so the handshake completes during ringing; the call
   # stays in `ringing` until status=ACCEPTED arrives. Don't gate on
@@ -171,13 +159,11 @@ class Whatsapp::IncomingCallService
     )
   end
 
-  # Ring the assignee if any, else online inbox agents, else fall back to the
-  # inbox's own agents and account admins. Never the whole-account stream, which
-  # would ring online agents from unrelated inboxes.
+  # Ring the assignee if any, else online inbox agents, else the whole account.
   def broadcast_incoming(call, sdp_offer)
     contact = call.contact
     token = call.conversation.assignee&.pubsub_token
-    streams = token ? [token] : (online_agent_streams.presence || fallback_agent_streams)
+    streams = token ? [token] : (online_agent_streams.presence || account_streams)
     broadcast(call, 'voice_call.incoming',
               streams: streams,
               direction: call.direction_label, inbox_id: call.inbox_id,
@@ -189,11 +175,6 @@ class Whatsapp::IncomingCallService
     inbox.available_agents.pluck('users.pubsub_token').compact
   end
 
-  def fallback_agent_streams
-    user_ids = inbox.member_ids | inbox.account.administrators.ids
-    User.where(id: user_ids).pluck(:pubsub_token).compact
-  end
-
   def broadcast(call, event, streams: account_streams, **extra)
     payload = { event: event, data: base_payload(call).merge(extra) }
     streams.each { |s| ActionCable.server.broadcast(s, payload) }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatwoot/chatwoot",
-  "version": "4.14.1",
+  "version": "4.14.0",
   "license": "MIT",
   "scripts": {
     "eslint": "eslint app/**/*.{js,vue}",

spec/controllers/api/v1/accounts/microsoft/authorization_controller_spec.rb

@@ -43,7 +43,6 @@ RSpec.describe 'Microsoft Authorization API', type: :request do
         ]
         expect(params['scope']).to eq(expected_scope)
         expect(params['redirect_uri']).to eq(["#{ENV.fetch('FRONTEND_URL', 'http://localhost:3000')}/microsoft/callback"])
-        expect(url).not_to match(/(?:\?|&)prompt=/)
 
         # Validate state parameter exists and can be decoded back to the account
         expect(params['state']).to be_present

spec/enterprise/controllers/api/v1/accounts/audit_logs_controller_spec.rb

@@ -51,13 +51,10 @@ RSpec.describe 'Enterprise Audit API', type: :request do
         expect(json_response['audit_logs'][1]['action']).to eql('create')
         expect(json_response['audit_logs'][1]['audited_changes']['name']).to eql(inbox.name)
         expect(json_response['audit_logs'][1]['associated_id']).to eql(account.id)
+        expect(json_response['current_page']).to be(1)
         # contains audit log for account user as well
         # contains audit logs for account update(enable audit logs)
-        expect(json_response.slice('current_page', 'per_page', 'total_entries')).to eql(
-          'current_page' => 1,
-          'per_page' => 25,
-          'total_entries' => 3
-        )
+        expect(json_response['total_entries']).to be(3)
       end
     end
   end

spec/enterprise/controllers/api/v1/accounts/captain/bulk_actions_controller_spec.rb

@@ -147,7 +147,7 @@ RSpec.describe 'Api::V1::Accounts::Captain::BulkActions', type: :request do
                  params: sync_params,
                  headers: admin.create_new_auth_token,
                  as: :json
-          end.to have_enqueued_job(Captain::Documents::PerformSyncJob).on_queue('low').exactly(documents.size).times
+          end.to have_enqueued_job(Captain::Documents::PerformSyncJob).exactly(documents.size).times
 
           documents.each do |document|
             expect(document.reload).to have_attributes(
@@ -190,7 +190,7 @@ RSpec.describe 'Api::V1::Accounts::Captain::BulkActions', type: :request do
         expect(response).to have_http_status(:ok)
       end
 
-      it 'queues documents that already have a sync in progress' do
+      it 'skips documents that already have a sync in progress' do
         syncing_document = create(:captain_document, assistant: assistant, account: account, status: :available)
         syncing_document.update!(sync_status: :syncing, last_sync_attempted_at: 1.minute.ago)
 
@@ -199,10 +199,9 @@ RSpec.describe 'Api::V1::Accounts::Captain::BulkActions', type: :request do
                params: sync_params.merge(ids: [syncing_document.id]),
                headers: admin.create_new_auth_token,
                as: :json
-        end.to have_enqueued_job(Captain::Documents::PerformSyncJob).with(syncing_document).on_queue('low')
+        end.not_to have_enqueued_job(Captain::Documents::PerformSyncJob)
 
         expect(response).to have_http_status(:ok)
-        expect(json_response).to eq({ ids: [syncing_document.id], count: 1 })
       end
 
       it 'queues stale syncing documents again' do

spec/enterprise/controllers/api/v1/accounts/captain/documents_controller_spec.rb

@@ -243,7 +243,7 @@ RSpec.describe 'Api::V1::Accounts::Captain::Documents', type: :request do
         before do
           create_list(:captain_document, 5, assistant: assistant, account: account)
 
-          InstallationConfig.find_or_initialize_by(name: 'CAPTAIN_CLOUD_PLAN_LIMITS').update!(value: captain_limits.to_json)
+          create(:installation_config, name: 'CAPTAIN_CLOUD_PLAN_LIMITS', value: captain_limits.to_json)
           post "/api/v1/accounts/#{account.id}/captain/documents",
                params: valid_attributes,
                headers: admin.create_new_auth_token
@@ -281,7 +281,7 @@ RSpec.describe 'Api::V1::Accounts::Captain::Documents', type: :request do
           expect do
             post "/api/v1/accounts/#{account.id}/captain/documents/#{document.id}/sync",
                  headers: admin.create_new_auth_token, as: :json
-          end.to have_enqueued_job(Captain::Documents::PerformSyncJob).with(document).on_queue('low')
+          end.to have_enqueued_job(Captain::Documents::PerformSyncJob).with(document)
 
           expect(document.reload).to have_attributes(
             sync_status: 'syncing',
@@ -292,15 +292,15 @@ RSpec.describe 'Api::V1::Accounts::Captain::Documents', type: :request do
         expect(response).to have_http_status(:accepted)
       end
 
-      it 'queues documents that already have a sync in progress' do
+      it 'rejects documents that already have a sync in progress' do
         document.update!(sync_status: :syncing, last_sync_attempted_at: 1.minute.ago)
 
         expect do
           post "/api/v1/accounts/#{account.id}/captain/documents/#{document.id}/sync",
                headers: admin.create_new_auth_token, as: :json
-        end.to have_enqueued_job(Captain::Documents::PerformSyncJob).with(document).on_queue('low')
+        end.not_to have_enqueued_job(Captain::Documents::PerformSyncJob)
 
-        expect(response).to have_http_status(:accepted)
+        expect(response).to have_http_status(:unprocessable_entity)
       end
 
       it 'queues stale syncing documents again' do

spec/enterprise/jobs/captain/documents/perform_sync_job_spec.rb

@@ -1,60 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe Captain::Documents::PerformSyncJob, type: :job do
-  let(:account) { create(:account) }
-  let(:assistant) { create(:captain_assistant, account: account) }
-  let(:document) { create(:captain_document, assistant: assistant, account: account, status: :available) }
-
-  def stub_lock(job)
-    allow(job).to receive(:with_lock).and_yield
-  end
-
-  def stub_page_fetch(content: 'Updated content')
-    fetch_result = Captain::Documents::SinglePageFetcher::Result.new(
-      success: true,
-      title: 'Updated title',
-      content: content
-    )
-    fetcher = instance_double(Captain::Documents::SinglePageFetcher, fetch: fetch_result)
-    allow(Captain::Documents::SinglePageFetcher).to receive(:new).and_return(fetcher)
-  end
-
-  def stub_page_fetch_failure
-    fetcher = instance_double(Captain::Documents::SinglePageFetcher)
-    allow(fetcher).to receive(:fetch).and_raise(StandardError, 'boom')
-    allow(Captain::Documents::SinglePageFetcher).to receive(:new).and_return(fetcher)
-  end
-
-  it 'syncs the document content' do
-    travel_to Time.zone.local(2026, 5, 18, 10, 0, 0) do
-      job = described_class.new
-      stub_lock(job)
-      stub_page_fetch
-
-      job.perform(document)
-
-      expect(document.reload).to have_attributes(
-        sync_status: 'synced',
-        last_sync_attempted_at: Time.current,
-        last_synced_at: Time.current,
-        content: 'Updated content'
-      )
-    end
-  end
-
-  it 'marks unexpected failures as failed' do
-    travel_to Time.zone.local(2026, 5, 18, 10, 0, 0) do
-      job = described_class.new
-      stub_lock(job)
-      stub_page_fetch_failure
-
-      expect { job.perform(document) }.to raise_error(StandardError, 'boom')
-
-      expect(document.reload).to have_attributes(
-        sync_status: 'failed',
-        last_sync_error_code: 'sync_error',
-        last_sync_attempted_at: Time.current
-      )
-    end
-  end
-end

spec/enterprise/jobs/captain/documents/schedule_syncs_job_spec.rb

@@ -5,28 +5,11 @@ RSpec.describe Captain::Documents::ScheduleSyncsJob, type: :job do
   let(:assistant) { create(:captain_assistant, account: account) }
 
   before do
-    set_installation_config('CAPTAIN_DOCUMENT_AUTO_SYNC_INTERVALS', { business: 168, enterprise: 24, startups: 720, hacker: nil }.to_json)
-    set_installation_config('CAPTAIN_DOCUMENT_AUTO_SYNC_PER_ACCOUNT_BATCH_LIMIT', 50)
-    set_installation_config('CAPTAIN_DOCUMENT_AUTO_SYNC_GLOBAL_BATCH_LIMIT', 1000)
+    create(:installation_config, name: 'CAPTAIN_DOCUMENT_AUTO_SYNC_INTERVALS', value: { business: 24, hacker: nil }.to_json)
     account.enable_features!('captain_document_auto_sync')
     clear_enqueued_jobs
   end
 
-  def set_installation_config(name, value)
-    InstallationConfig.find_or_initialize_by(name: name).tap do |config|
-      config.value = value
-      config.save!
-    end
-  end
-
-  def update_sync_limit(name, value)
-    InstallationConfig.find_by!(name: name).update!(value: value)
-  end
-
-  def sync_job_for(document)
-    have_enqueued_job(Captain::Documents::PerformSyncJob).with(document)
-  end
-
   context 'when the account has not enabled auto-sync' do
     before { account.disable_features!('captain_document_auto_sync') }
 
@@ -49,25 +32,6 @@ RSpec.describe Captain::Documents::ScheduleSyncsJob, type: :job do
     end
   end
 
-  context 'when a plan name is passed' do
-    it 'queues due documents only for that plan' do
-      enterprise_account = create(:account, custom_attributes: { plan_name: 'Enterprise' })
-      enterprise_account.enable_features!('captain_document_auto_sync')
-      enterprise_assistant = create(:captain_assistant, account: enterprise_account)
-      business_document = create(:captain_document, assistant: assistant, account: account, status: :available)
-      enterprise_document = create(:captain_document, assistant: enterprise_assistant, account: enterprise_account, status: :available)
-
-      business_document.update!(sync_status: :synced, last_synced_at: 3.days.ago, last_sync_attempted_at: 3.days.ago)
-      enterprise_document.update!(sync_status: :synced, last_synced_at: 3.days.ago, last_sync_attempted_at: 3.days.ago)
-      clear_enqueued_jobs
-
-      described_class.new.perform('enterprise')
-
-      expect(Captain::Documents::PerformSyncJob).to have_been_enqueued.with(enterprise_document)
-      expect(Captain::Documents::PerformSyncJob).not_to have_been_enqueued.with(business_document)
-    end
-  end
-
   context 'when an available document has backfilled sync metadata' do
     it 'leaves it alone when last synced within the plan cadence' do
       create(
@@ -90,34 +54,53 @@ RSpec.describe Captain::Documents::ScheduleSyncsJob, type: :job do
         account: account,
         status: :available,
         sync_status: :synced,
-        last_synced_at: 8.days.ago
+        last_synced_at: 3.days.ago
       )
       clear_enqueued_jobs
 
       expect { described_class.new.perform }
-        .to sync_job_for(document).on_queue('purgable')
+        .to have_enqueued_job(Captain::Documents::PerformSyncJob).with(document)
     end
 
-    it 'delays only the queued sync job' do
+    it 'marks the due document as syncing before queueing' do
       travel_to Time.zone.local(2026, 4, 27, 10, 0, 0) do
-        job = described_class.new
-        allow(job).to receive(:rand).and_return(30.minutes.to_i)
         document = create(
           :captain_document,
           assistant: assistant,
           account: account,
           status: :available,
           sync_status: :synced,
-          last_synced_at: 8.days.ago
+          last_synced_at: 3.days.ago
         )
         clear_enqueued_jobs
 
-        job.perform
+        described_class.new.perform
 
-        expect(Captain::Documents::PerformSyncJob)
-          .to have_been_enqueued.with(document).at(30.minutes.from_now)
+        expect(document.reload).to have_attributes(
+          sync_status: 'syncing',
+          last_sync_attempted_at: Time.current
+        )
       end
     end
+
+    it 'does not queue the same document again while the reserved sync is fresh' do
+      document = create(
+        :captain_document,
+        assistant: assistant,
+        account: account,
+        status: :available,
+        sync_status: :synced,
+        last_synced_at: 2.days.ago
+      )
+      clear_enqueued_jobs
+
+      expect { described_class.new.perform }
+        .to have_enqueued_job(Captain::Documents::PerformSyncJob).with(document)
+
+      clear_enqueued_jobs
+
+      expect { described_class.new.perform }.not_to have_enqueued_job(Captain::Documents::PerformSyncJob)
+    end
   end
 
   context 'when an available document was synced within the plan cadence' do
@@ -133,59 +116,78 @@ RSpec.describe Captain::Documents::ScheduleSyncsJob, type: :job do
   context 'when an available document was last synced before the plan cadence' do
     it 'queues a sync for that document' do
       document = create(:captain_document, assistant: assistant, account: account, status: :available)
-      document.update!(sync_status: :synced, last_synced_at: 8.days.ago, last_sync_attempted_at: 8.days.ago)
+      document.update!(sync_status: :synced, last_synced_at: 2.days.ago, last_sync_attempted_at: 2.days.ago)
       clear_enqueued_jobs
 
       expect { described_class.new.perform }
-        .to sync_job_for(document)
-    end
-  end
-
-  context 'when jitter spreads queued sync execution' do
-    it 'uses a widened due window so jittered syncs do not skip the next plan run' do
-      travel_to Time.zone.local(2026, 4, 27, 10, 0, 0) do
-        job = described_class.new
-        interval = 1.week
-        due_window = (interval.to_i / 2).seconds
-        allow(job).to receive(:rand).and_return(2.hours.to_i)
-        document = create(:captain_document, assistant: assistant, account: account, status: :available)
-
-        document.update!(sync_status: :synced, last_synced_at: (due_window - 1.minute).ago)
-        clear_enqueued_jobs
-
-        expect { job.perform }.not_to have_enqueued_job(Captain::Documents::PerformSyncJob)
-
-        document.update!(sync_status: :synced, last_synced_at: (due_window + 1.minute).ago)
-        clear_enqueued_jobs
-
-        expect { job.perform }
-          .to have_enqueued_job(Captain::Documents::PerformSyncJob)
-          .with(document)
-          .on_queue('purgable')
-          .at(2.hours.from_now)
-      end
+        .to have_enqueued_job(Captain::Documents::PerformSyncJob).with(document)
     end
 
-    it 'uses a random delay inside the cadence window' do
-      travel_to Time.zone.local(2026, 4, 27, 10, 0, 0) do
-        document = create(:captain_document, assistant: assistant, account: account, status: :available)
-        document.update!(sync_status: :synced, last_synced_at: 8.days.ago)
-        job = described_class.new
-        sync_execution_delay = 12_345.seconds
+    it 'skips invalid legacy documents without counting them against the account cap' do
+      stub_const("#{described_class}::PER_ACCOUNT_HOURLY_CAP", 1)
+      create(
+        :captain_document,
+        assistant: assistant,
+        account: account,
+        status: :in_progress,
+        content: nil,
+        external_link: 'https://example.com'
+      )
+      invalid_document = build(
+        :captain_document,
+        assistant: assistant,
+        account: account,
+        status: :available,
+        sync_status: :synced,
+        last_synced_at: 2.days.ago,
+        last_sync_attempted_at: 2.days.ago,
+        external_link: 'https://example.com/'
+      )
+      invalid_document.save!(validate: false)
+      valid_document = create(:captain_document, assistant: assistant, account: account, status: :available)
+      valid_document.update!(sync_status: :synced, last_synced_at: 2.days.ago, last_sync_attempted_at: 2.days.ago)
+      clear_enqueued_jobs
 
-        clear_enqueued_jobs
-        allow(job).to receive(:rand).with(0..described_class::WEEKLY_SYNC_JITTER.to_i).and_return(sync_execution_delay.to_i)
+      expect { described_class.new.perform }.not_to raise_error
+      expect(Captain::Documents::PerformSyncJob).not_to have_been_enqueued.with(invalid_document)
+      expect(Captain::Documents::PerformSyncJob).to have_been_enqueued.with(valid_document)
+    end
 
-        expect { job.perform }
-          .to sync_job_for(document)
-          .at(sync_execution_delay.from_now)
-      end
+    it 'keeps paging due documents when invalid documents fill the first batch' do
+      stub_const("#{described_class}::PER_ACCOUNT_HOURLY_CAP", 1)
+      stub_const("#{described_class}::DUE_DOCUMENT_BATCH_SIZE", 1)
+      create(
+        :captain_document,
+        assistant: assistant,
+        account: account,
+        status: :in_progress,
+        content: nil,
+        external_link: 'https://example.com'
+      )
+      invalid_document = build(
+        :captain_document,
+        assistant: assistant,
+        account: account,
+        status: :available,
+        sync_status: :synced,
+        last_synced_at: 2.days.ago,
+        last_sync_attempted_at: 3.days.ago,
+        external_link: 'https://example.com/'
+      )
+      invalid_document.save!(validate: false)
+      valid_document = create(:captain_document, assistant: assistant, account: account, status: :available)
+      valid_document.update!(sync_status: :synced, last_synced_at: 2.days.ago, last_sync_attempted_at: 2.days.ago)
+      clear_enqueued_jobs
+
+      described_class.new.perform
+
+      expect(Captain::Documents::PerformSyncJob).to have_been_enqueued.with(valid_document)
     end
   end
 
   context 'when more documents are due than the account cap allows' do
     before do
-      update_sync_limit('CAPTAIN_DOCUMENT_AUTO_SYNC_PER_ACCOUNT_BATCH_LIMIT', 2)
+      stub_const("#{described_class}::PER_ACCOUNT_HOURLY_CAP", 2)
     end
 
     it 'queues backfilled and oldest-attempted documents first' do
@@ -193,47 +195,26 @@ RSpec.describe Captain::Documents::ScheduleSyncsJob, type: :job do
       oldest_document = create(:captain_document, assistant: assistant, account: account, status: :available)
       backfilled_document = create(:captain_document, assistant: assistant, account: account, status: :available)
 
-      newest_document.update!(sync_status: :synced, last_synced_at: 8.days.ago, last_sync_attempted_at: 8.days.ago)
-      oldest_document.update!(sync_status: :synced, last_synced_at: 9.days.ago, last_sync_attempted_at: 9.days.ago)
-      backfilled_document.update!(sync_status: :synced, last_synced_at: 10.days.ago, last_sync_attempted_at: nil)
+      newest_document.update!(sync_status: :synced, last_synced_at: 2.days.ago, last_sync_attempted_at: 2.days.ago)
+      oldest_document.update!(sync_status: :synced, last_synced_at: 3.days.ago, last_sync_attempted_at: 3.days.ago)
+      backfilled_document.update!(sync_status: :synced, last_synced_at: 4.days.ago, last_sync_attempted_at: nil)
       clear_enqueued_jobs
 
       expect { described_class.new.perform }
-        .to sync_job_for(backfilled_document)
-        .and sync_job_for(oldest_document)
+        .to have_enqueued_job(Captain::Documents::PerformSyncJob).with(backfilled_document)
+        .and have_enqueued_job(Captain::Documents::PerformSyncJob).with(oldest_document)
       expect(Captain::Documents::PerformSyncJob).not_to have_been_enqueued.with(newest_document)
     end
   end
 
-  context 'when sync caps are configured' do
-    it 'uses installation config caps for per-account and global limits' do
-      update_sync_limit('CAPTAIN_DOCUMENT_AUTO_SYNC_PER_ACCOUNT_BATCH_LIMIT', 2)
-      update_sync_limit('CAPTAIN_DOCUMENT_AUTO_SYNC_GLOBAL_BATCH_LIMIT', 3)
-
-      second_account = create(:account, custom_attributes: { plan_name: 'business' })
-      second_account.enable_features!('captain_document_auto_sync')
-      second_assistant = create(:captain_assistant, account: second_account)
-
-      first_account_documents = create_list(:captain_document, 3, assistant: assistant, account: account, status: :available)
-      second_account_documents = create_list(:captain_document, 3, assistant: second_assistant, account: second_account, status: :available)
-      (first_account_documents + second_account_documents).each do |document|
-        document.update!(sync_status: :synced, last_synced_at: 8.days.ago, last_sync_attempted_at: 8.days.ago)
-      end
-      clear_enqueued_jobs
-
-      expect { described_class.new.perform }
-        .to have_enqueued_job(Captain::Documents::PerformSyncJob).exactly(3).times
-    end
-  end
-
   context 'when an available document failed before the plan cadence' do
     it 'queues a sync for that document' do
       document = create(:captain_document, assistant: assistant, account: account, status: :available)
-      document.update!(sync_status: :failed, last_sync_attempted_at: 8.days.ago)
+      document.update!(sync_status: :failed, last_sync_attempted_at: 2.days.ago)
       clear_enqueued_jobs
 
       expect { described_class.new.perform }
-        .to sync_job_for(document)
+        .to have_enqueued_job(Captain::Documents::PerformSyncJob).with(document)
     end
   end
 
@@ -247,7 +228,7 @@ RSpec.describe Captain::Documents::ScheduleSyncsJob, type: :job do
       clear_enqueued_jobs
 
       expect { described_class.new.perform }
-        .to sync_job_for(document)
+        .to have_enqueued_job(Captain::Documents::PerformSyncJob).with(document)
     end
   end
 

spec/enterprise/jobs/enterprise/internal/trigger_daily_scheduled_items_job_spec.rb

@@ -1,42 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe Internal::TriggerDailyScheduledItemsJob do
-  before do
-    allow(ChatwootHub).to receive(:installation_identifier).and_return('test-installation-id')
-    allow(Captain::Documents::ScheduleSyncsJob).to receive(:perform_later)
-  end
-
-  it 'enqueues enterprise Captain document auto-sync every day' do
-    travel_to Time.zone.parse('2026-05-26 00:00:00 UTC') do
-      described_class.perform_now
-    end
-
-    expect(Captain::Documents::ScheduleSyncsJob).to have_received(:perform_later).with('enterprise')
-  end
-
-  it 'enqueues business Captain document auto-sync weekly' do
-    travel_to Time.zone.parse('2026-05-24 00:00:00 UTC') do
-      described_class.perform_now
-    end
-
-    expect(Captain::Documents::ScheduleSyncsJob).to have_received(:perform_later).with('business')
-  end
-
-  it 'enqueues startup Captain document auto-sync monthly' do
-    travel_to Time.zone.parse('2026-06-01 00:00:00 UTC') do
-      described_class.perform_now
-    end
-
-    expect(Captain::Documents::ScheduleSyncsJob).to have_received(:perform_later).with('startups')
-  end
-
-  it 'does not enqueue business or startup Captain document auto-sync before their plan window' do
-    travel_to Time.zone.parse('2026-05-25 00:00:00 UTC') do
-      described_class.perform_now
-    end
-
-    expect(Captain::Documents::ScheduleSyncsJob).to have_received(:perform_later).with('enterprise')
-    expect(Captain::Documents::ScheduleSyncsJob).not_to have_received(:perform_later).with('business')
-    expect(Captain::Documents::ScheduleSyncsJob).not_to have_received(:perform_later).with('startups')
-  end
-end

spec/enterprise/services/messages/audio_transcription_service_spec.rb

@@ -72,7 +72,7 @@ RSpec.describe Messages::AudioTranscriptionService, type: :service do
           content_type: 'audio/mpeg'
         )
         allow(service).to receive(:can_transcribe?).and_return(true)
-        allow(attachment.file.blob).to receive(:byte_size).and_return(described_class::TRANSCRIPTION_BYTE_LIMIT + 1)
+        allow(attachment.file.blob).to receive(:byte_size).and_return(described_class::WHISPER_BYTE_LIMIT + 1)
       end
 
       it 'returns an error without calling Whisper' do

spec/enterprise/services/whatsapp/incoming_call_service_spec.rb

@@ -32,9 +32,6 @@ describe Whatsapp::IncomingCallService do
 
   describe 'inbound connect' do
     let(:sdp_offer) { "v=0\r\n...sdp..." }
-    let!(:agent) { create(:user, account: account) }
-
-    before { create(:inbox_member, inbox: inbox, user: agent) }
 
     it 'creates the Call + Conversation + voice_call message and broadcasts voice_call.incoming' do
       allow(ActionCable.server).to receive(:broadcast)
@@ -47,15 +44,9 @@ describe Whatsapp::IncomingCallService do
       expect(call).to have_attributes(provider: 'whatsapp', direction: 'incoming', status: 'ringing',
                                       provider_call_id: provider_call_id)
       expect(call.meta['sdp_offer']).to eq(sdp_offer)
-      # No agent is online, so the call falls back to the inbox's agents (and
-      # account admins) — never the whole-account stream.
       expect(ActionCable.server).to have_received(:broadcast).with(
-        agent.pubsub_token,
-        hash_including(event: 'voice_call.incoming', data: hash_including(sdp_offer: sdp_offer))
-      )
-      expect(ActionCable.server).not_to have_received(:broadcast).with(
         "account_#{account.id}",
-        hash_including(event: 'voice_call.incoming')
+        hash_including(event: 'voice_call.incoming', data: hash_including(sdp_offer: sdp_offer))
       )
     end
   end

spec/models/channel/whatsapp_spec.rb

@@ -223,12 +223,12 @@ RSpec.describe Channel::Whatsapp do
       expect(channel.voice_enabled?).to be true
     end
 
-    it 'returns true for manual whatsapp_cloud channels with calling_enabled' do
+    it 'returns false for whatsapp_cloud channels without embedded_signup source' do
       channel = create(:channel_whatsapp, account: account, provider: 'whatsapp_cloud',
                                           validate_provider_config: false, sync_templates: false)
       channel.update!(provider_config: channel.provider_config.merge('source' => 'manual', 'calling_enabled' => true))
 
-      expect(channel.voice_enabled?).to be true
+      expect(channel.voice_enabled?).to be false
     end
 
     it 'returns false for default-provider channels (360dialog) even with calling_enabled' do

swagger/paths/application/audit_logs/index.yml

@@ -24,7 +24,7 @@ responses:
             per_page:
               type: integer
               description: Number of items per page
-              example: 25
+              example: 15
             total_entries:
               type: integer
               description: Total number of audit log entries
@@ -49,4 +49,4 @@ responses:
     content:
       application/json:
         schema:
-          $ref: '#/components/schemas/bad_request_error'
+          $ref: '#/components/schemas/bad_request_error'

swagger/swagger.json

@@ -1649,7 +1649,7 @@
                     "per_page": {
                       "type": "integer",
                       "description": "Number of items per page",
-                      "example": 25
+                      "example": 15
                     },
                     "total_entries": {
                       "type": "integer",

swagger/tag_groups/application_swagger.json

@@ -192,7 +192,7 @@
                     "per_page": {
                       "type": "integer",
                       "description": "Number of items per page",
-                      "example": 25
+                      "example": 15
                     },
                     "total_entries": {
                       "type": "integer",