From 0f3bb640f557dea847eaf900883a995027fb7e90 Mon Sep 17 00:00:00 2001
From: Pranav <pranav@chatwoot.com>
Date: Fri, 7 Aug 2026 00:55:48 -0700
Subject: [PATCH] feat(captain): Add audience and schedule controls for
 assistants (#14902)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Captain assistants now support **audience** and **schedule** controls,
so you can decide *who* an assistant replies to and *when* it's on duty.
By default nothing changes, an assistant still responds to every
conversation in its connected inboxes but you can now narrow that down.

- **Audience**: build a condition tree (contact attributes, conversation
attributes, and custom attributes) with and/or groups, mirroring the
contact-segment filter semantics. Only conversations whose contact
matches the audience get a Captain reply.
- **Schedule**: choose when Captain replies — *Anytime*, *During
business hours*, or *Outside business hours* (based on each inbox's
configured working hours; inboxes without business hours are always
covered).

When an assistant opts out of a conversation (contact outside the
audience, or off-schedule), the conversation is routed to the human
queue instead of being parked pending on a silent bot — both on initial
creation and on reopen.

Fixes
https://linear.app/chatwoot/issue/CW-7414/audience-and-availability-controls

|Audience|Availability|
|--|--|
| <img width="1132" height="627" alt="Screenshot 2026-06-30 at 5 52
09 PM"
src="https://github.com/user-attachments/assets/866910e0-e1d7-4248-8630-d91afc758688"
/> | <img width="1131" height="539" alt="Screenshot 2026-06-30 at 5 52
13 PM"
src="https://github.com/user-attachments/assets/aad0d6f7-ceb7-4546-a049-095c5b46b483"
/> |

## How to test

1. Open **Captain → Assistants → (an assistant) → Settings**.
2. Under **Audience**, add a condition or condition group (e.g. `Contact
language equal_to en`) and save. Start a conversation from a contact
that does *not* match — Captain should stay silent and the conversation
should land in the human (open) queue instead of pending.
3. With a matching contact, Captain should respond as before.
4. Under **Schedule**, pick **During business hours** (or **Outside
business hours**) on an inbox that has working hours configured, and
confirm Captain only engages within/outside that window. An
empty/`Anytime` schedule always responds.

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Co-authored-by: Aakash Bakhle <48802744+aakashb95@users.noreply.github.com>
Co-authored-by: aakashb95 <aakashbakhle@gmail.com>
Co-authored-by: iamsivin <iamsivin@gmail.com>
---
 .../settings/AssistantAudienceForm.spec.js    |  36 +++
 .../settings/AssistantAudienceForm.vue        | 195 +++++++++++++
 .../settings/AssistantScheduleForm.vue        |  73 +++++
 .../assistant/settings/SettingsPageLayout.vue | 116 ++++++++
 .../settings/audience/AudienceGroup.vue       | 167 +++++++++++
 .../audience/useAudienceFilterTypes.js        | 131 +++++++++
 .../audience/useAudienceFilterTypes.spec.js   |  98 +++++++
 .../components-next/filter/ConditionRow.vue   |   2 +
 .../components-next/filter/contactProvider.js |  10 -
 .../filter/inputs/FilterSelect.vue            |  45 ++-
 .../components-next/sidebar/Sidebar.vue       |   3 +
 .../i18n/locale/en/advancedFilters.json       |   2 +
 .../i18n/locale/en/integrations.json          |  50 ++++
 .../captain/assistants/guardrails/Index.vue   | 249 +++++++---------
 .../captain/assistants/guidelines/Index.vue   | 275 ++++++++----------
 .../captain/assistants/settings/Audience.vue  |  18 ++
 .../captain/assistants/settings/Index.vue     |  91 ++++++
 .../captain/assistants/settings/Schedule.vue  |  18 ++
 .../captain/assistants/settings/Settings.vue  | 196 -------------
 .../captain/assistants/settings/System.vue    |  21 ++
 .../settings/useAssistantSettings.js          |  31 ++
 .../settings/useAssistantSettings.spec.js     |  71 +++++
 .../dashboard/captain/captain.routes.js       |  31 +-
 .../accounts/captain/assistants_controller.rb |  15 +-
 enterprise/app/models/captain/assistant.rb    |  32 +-
 .../app/models/enterprise/conversation.rb     |   9 +
 enterprise/app/models/enterprise/message.rb   |   9 +
 .../app/services/captain/audience_matcher.rb  | 180 ++++++++++++
 .../response_scheduler_service.rb             |  58 ++++
 .../hook_execution_service.rb                 |  62 +---
 .../validators/captain/audience_validator.rb  |  77 +++++
 .../captain/assistants_controller_spec.rb     |  41 +++
 .../models/captain/assistant_spec.rb          | 206 ++++++++++++-
 .../models/enterprise/conversation_spec.rb    |  28 ++
 .../services/captain/audience_matcher_spec.rb | 194 ++++++++++++
 .../hook_execution_service_spec.rb            |  86 ++++++
 36 files changed, 2363 insertions(+), 563 deletions(-)
 create mode 100644 app/javascript/dashboard/components-next/captain/pageComponents/assistant/settings/AssistantAudienceForm.spec.js
 create mode 100644 app/javascript/dashboard/components-next/captain/pageComponents/assistant/settings/AssistantAudienceForm.vue
 create mode 100644 app/javascript/dashboard/components-next/captain/pageComponents/assistant/settings/AssistantScheduleForm.vue
 create mode 100644 app/javascript/dashboard/components-next/captain/pageComponents/assistant/settings/SettingsPageLayout.vue
 create mode 100644 app/javascript/dashboard/components-next/captain/pageComponents/assistant/settings/audience/AudienceGroup.vue
 create mode 100644 app/javascript/dashboard/components-next/captain/pageComponents/assistant/settings/audience/useAudienceFilterTypes.js
 create mode 100644 app/javascript/dashboard/components-next/captain/pageComponents/assistant/settings/audience/useAudienceFilterTypes.spec.js
 create mode 100644 app/javascript/dashboard/routes/dashboard/captain/assistants/settings/Audience.vue
 create mode 100644 app/javascript/dashboard/routes/dashboard/captain/assistants/settings/Index.vue
 create mode 100644 app/javascript/dashboard/routes/dashboard/captain/assistants/settings/Schedule.vue
 delete mode 100644 app/javascript/dashboard/routes/dashboard/captain/assistants/settings/Settings.vue
 create mode 100644 app/javascript/dashboard/routes/dashboard/captain/assistants/settings/System.vue
 create mode 100644 app/javascript/dashboard/routes/dashboard/captain/assistants/settings/useAssistantSettings.js
 create mode 100644 app/javascript/dashboard/routes/dashboard/captain/assistants/settings/useAssistantSettings.spec.js
 create mode 100644 enterprise/app/services/captain/audience_matcher.rb
 create mode 100644 enterprise/app/services/captain/conversation/response_scheduler_service.rb
 create mode 100644 enterprise/app/validators/captain/audience_validator.rb
 create mode 100644 spec/enterprise/models/enterprise/conversation_spec.rb
 create mode 100644 spec/enterprise/services/captain/audience_matcher_spec.rb

diff --git a/app/javascript/dashboard/components-next/captain/pageComponents/assistant/settings/AssistantAudienceForm.spec.js b/app/javascript/dashboard/components-next/captain/pageComponents/assistant/settings/AssistantAudienceForm.spec.js
new file mode 100644
index 000000000..21b42e580
--- /dev/null
+++ b/app/javascript/dashboard/components-next/captain/pageComponents/assistant/settings/AssistantAudienceForm.spec.js
@@ -0,0 +1,36 @@
+import { nextTick } from 'vue';
+import { shallowMount } from '@vue/test-utils';
+import { describe, expect, it, vi } from 'vitest';
+import Button from 'dashboard/components-next/button/Button.vue';
+import RadioCard from 'dashboard/components-next/radioCard/RadioCard.vue';
+import AssistantAudienceForm from './AssistantAudienceForm.vue';
+
+vi.mock('vue-i18n', () => ({
+  useI18n: () => ({ t: key => key }),
+}));
+
+vi.mock('./audience/useAudienceFilterTypes.js', () => ({
+  useAudienceFilterTypes: () => ({ filterTypes: [] }),
+}));
+
+const mountComponent = () =>
+  shallowMount(AssistantAudienceForm, {
+    props: { assistant: { config: {} } },
+    global: { stubs: { RadioCard: false } },
+  });
+
+describe('AssistantAudienceForm', () => {
+  it('does not submit a specific audience without conditions', async () => {
+    const wrapper = mountComponent();
+
+    wrapper.findAllComponents(RadioCard)[1].vm.$emit('select', 'specific');
+    await nextTick();
+    wrapper.findComponent(Button).vm.$emit('click');
+    await nextTick();
+
+    expect(wrapper.emitted('submit')).toBeUndefined();
+    expect(wrapper.text()).toContain(
+      'CAPTAIN.ASSISTANTS.FORM.AUDIENCE.EMPTY_ERROR'
+    );
+  });
+});
diff --git a/app/javascript/dashboard/components-next/captain/pageComponents/assistant/settings/AssistantAudienceForm.vue b/app/javascript/dashboard/components-next/captain/pageComponents/assistant/settings/AssistantAudienceForm.vue
new file mode 100644
index 000000000..b07cf7634
--- /dev/null
+++ b/app/javascript/dashboard/components-next/captain/pageComponents/assistant/settings/AssistantAudienceForm.vue
@@ -0,0 +1,195 @@
+<script setup>
+import { ref, watch, useTemplateRef } from 'vue';
+import { useI18n } from 'vue-i18n';
+import Button from 'dashboard/components-next/button/Button.vue';
+import RadioCard from 'dashboard/components-next/radioCard/RadioCard.vue';
+import AudienceGroup from './audience/AudienceGroup.vue';
+import { useAudienceFilterTypes } from './audience/useAudienceFilterTypes.js';
+
+const props = defineProps({
+  assistant: {
+    type: Object,
+    default: () => ({}),
+  },
+});
+
+const emit = defineEmits(['submit']);
+
+const { t } = useI18n();
+const { filterTypes } = useAudienceFilterTypes();
+
+const MODE = {
+  EVERYONE: 'everyone',
+  SPECIFIC: 'specific',
+};
+
+let uid = 0;
+const nextId = () => {
+  uid += 1;
+  return `audience-root-${uid}`;
+};
+
+const hasConditions = node =>
+  node && Object.prototype.hasOwnProperty.call(node, 'conditions');
+
+const defaultRoot = () => ({ id: nextId(), operator: 'and', conditions: [] });
+
+const root = ref(defaultRoot());
+const mode = ref(MODE.EVERYONE);
+const showEmptyAudienceError = ref(false);
+
+const findOption = (filterType, value) =>
+  filterType?.options?.find(option => String(option.id) === String(value));
+
+const hydrateValues = (leaf, filterType) => {
+  const raw = Array.isArray(leaf.values) ? leaf.values : [leaf.values];
+  const inputType = filterType?.inputType;
+  if (inputType === 'multiSelect') {
+    return raw.map(
+      value => findOption(filterType, value) ?? { id: value, name: value }
+    );
+  }
+  if (['searchSelect', 'booleanSelect'].includes(inputType)) {
+    return findOption(filterType, raw[0]) ?? { id: raw[0], name: raw[0] };
+  }
+  return raw[0] ?? '';
+};
+
+const hydrateNode = node => {
+  if (hasConditions(node)) {
+    return {
+      id: nextId(),
+      operator: node.operator || 'and',
+      conditions: (node.conditions || []).map(hydrateNode),
+    };
+  }
+
+  const filterType = filterTypes.value.find(
+    type => type.attributeKey === node.attribute_key
+  );
+  return {
+    id: nextId(),
+    attributeKey: node.attribute_key,
+    filterOperator: node.filter_operator,
+    values: hydrateValues(node, filterType),
+    attributeModel: filterType?.attributeModel || 'standard',
+  };
+};
+
+const hydrateRoot = audience => {
+  if (!audience) return defaultRoot();
+  const hydrated = hydrateNode(audience);
+  return hasConditions(hydrated)
+    ? hydrated
+    : { id: nextId(), operator: 'and', conditions: [hydrated] };
+};
+
+const serializeValues = values => {
+  if (Array.isArray(values)) {
+    return values[0]?.id ? values.map(value => value.id) : values;
+  }
+  if (values && typeof values === 'object') {
+    return [values.id];
+  }
+  if (values === '' || values === null || values === undefined) {
+    return [];
+  }
+  return [values];
+};
+
+const serializeNode = node => {
+  if (hasConditions(node)) {
+    return {
+      operator: node.operator,
+      conditions: node.conditions.map(serializeNode),
+    };
+  }
+  return {
+    attribute_key: node.attributeKey,
+    filter_operator: node.filterOperator,
+    values: serializeValues(node.values),
+  };
+};
+
+const groupRef = useTemplateRef('groupRef');
+
+const handleSubmit = () => {
+  const isSpecific = mode.value === MODE.SPECIFIC;
+  if (isSpecific && !root.value.conditions.length) {
+    showEmptyAudienceError.value = true;
+    return;
+  }
+
+  showEmptyAudienceError.value = false;
+  if (isSpecific && !groupRef.value.validate()) return;
+
+  const audience =
+    isSpecific && root.value.conditions.length
+      ? serializeNode(root.value)
+      : null;
+
+  emit('submit', {
+    config: {
+      ...props.assistant.config,
+      audience,
+    },
+  });
+};
+
+watch(
+  () => props.assistant,
+  newAssistant => {
+    if (!newAssistant) return;
+    const audience = newAssistant.config?.audience;
+    root.value = hydrateRoot(audience);
+    mode.value = audience ? MODE.SPECIFIC : MODE.EVERYONE;
+  },
+  { immediate: true }
+);
+
+watch(
+  () => root.value.conditions.length,
+  () => {
+    showEmptyAudienceError.value = false;
+  }
+);
+</script>
+
+<template>
+  <div class="flex flex-col gap-4">
+    <div class="flex flex-col gap-3">
+      <RadioCard
+        :id="MODE.EVERYONE"
+        :label="t('CAPTAIN.ASSISTANTS.FORM.AUDIENCE.EVERYONE.LABEL')"
+        :description="t('CAPTAIN.ASSISTANTS.FORM.AUDIENCE.EVERYONE.DESC')"
+        :is-active="mode === MODE.EVERYONE"
+        @select="mode = MODE.EVERYONE"
+      />
+      <RadioCard
+        :id="MODE.SPECIFIC"
+        :label="t('CAPTAIN.ASSISTANTS.FORM.AUDIENCE.SPECIFIC.LABEL')"
+        :description="t('CAPTAIN.ASSISTANTS.FORM.AUDIENCE.SPECIFIC.DESC')"
+        :is-active="mode === MODE.SPECIFIC"
+        @select="mode = MODE.SPECIFIC"
+      >
+        <AudienceGroup
+          v-if="mode === MODE.SPECIFIC"
+          ref="groupRef"
+          v-model="root"
+          is-root
+          class="w-full mt-2"
+          :filter-types="filterTypes"
+        />
+        <p v-if="showEmptyAudienceError" class="mt-2 text-sm text-n-ruby-11">
+          {{ t('CAPTAIN.ASSISTANTS.FORM.AUDIENCE.EMPTY_ERROR') }}
+        </p>
+      </RadioCard>
+    </div>
+    <div>
+      <Button
+        :label="t('CAPTAIN.ASSISTANTS.FORM.UPDATE')"
+        @click="handleSubmit"
+      />
+    </div>
+  </div>
+</template>
diff --git a/app/javascript/dashboard/components-next/captain/pageComponents/assistant/settings/AssistantScheduleForm.vue b/app/javascript/dashboard/components-next/captain/pageComponents/assistant/settings/AssistantScheduleForm.vue
new file mode 100644
index 000000000..10e304dc2
--- /dev/null
+++ b/app/javascript/dashboard/components-next/captain/pageComponents/assistant/settings/AssistantScheduleForm.vue
@@ -0,0 +1,73 @@
+<script setup>
+import { ref, watch } from 'vue';
+import { useI18n } from 'vue-i18n';
+import Button from 'dashboard/components-next/button/Button.vue';
+import RadioCard from 'dashboard/components-next/radioCard/RadioCard.vue';
+
+const props = defineProps({
+  assistant: {
+    type: Object,
+    default: () => ({}),
+  },
+});
+
+const emit = defineEmits(['submit']);
+
+const { t } = useI18n();
+
+const RESPONSE_WINDOW = {
+  ALWAYS: 'always',
+  BUSINESS_HOURS: 'business_hours',
+  OUTSIDE_BUSINESS_HOURS: 'outside_business_hours',
+};
+
+const OPTIONS = Object.values(RESPONSE_WINDOW);
+
+const selected = ref(RESPONSE_WINDOW.ALWAYS);
+
+const handleSubmit = () => {
+  emit('submit', {
+    config: { ...props.assistant.config, response_window: selected.value },
+  });
+};
+
+watch(
+  () => props.assistant,
+  newAssistant => {
+    if (newAssistant) {
+      selected.value =
+        newAssistant.config?.response_window || RESPONSE_WINDOW.ALWAYS;
+    }
+  },
+  { immediate: true }
+);
+</script>
+
+<template>
+  <div class="flex flex-col gap-4">
+    <div class="flex flex-col gap-3">
+      <RadioCard
+        v-for="option in OPTIONS"
+        :id="option"
+        :key="option"
+        :label="
+          t(`CAPTAIN.ASSISTANTS.FORM.SCHEDULE.${option.toUpperCase()}.LABEL`)
+        "
+        :description="
+          t(`CAPTAIN.ASSISTANTS.FORM.SCHEDULE.${option.toUpperCase()}.DESC`)
+        "
+        :is-active="selected === option"
+        @select="selected = $event"
+      />
+    </div>
+    <p class="text-sm text-n-slate-11">
+      {{ t('CAPTAIN.ASSISTANTS.FORM.SCHEDULE.HINT') }}
+    </p>
+    <div>
+      <Button
+        :label="t('CAPTAIN.ASSISTANTS.FORM.UPDATE')"
+        @click="handleSubmit"
+      />
+    </div>
+  </div>
+</template>
diff --git a/app/javascript/dashboard/components-next/captain/pageComponents/assistant/settings/SettingsPageLayout.vue b/app/javascript/dashboard/components-next/captain/pageComponents/assistant/settings/SettingsPageLayout.vue
new file mode 100644
index 000000000..fbb499f47
--- /dev/null
+++ b/app/javascript/dashboard/components-next/captain/pageComponents/assistant/settings/SettingsPageLayout.vue
@@ -0,0 +1,116 @@
+<script setup>
+import { computed } from 'vue';
+import { useRoute, useRouter } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { FEATURE_FLAGS } from 'dashboard/featureFlags';
+import { useAccount } from 'dashboard/composables/useAccount';
+import { useMapGetter } from 'dashboard/composables/store';
+import PageLayout from 'dashboard/components-next/captain/PageLayout.vue';
+import SettingsHeader from 'dashboard/components-next/captain/pageComponents/settings/SettingsHeader.vue';
+import VerticalTabs from 'dashboard/components-next/vertical-tabs/VerticalTabs.vue';
+
+defineProps({
+  heading: {
+    type: String,
+    required: true,
+  },
+  description: {
+    type: String,
+    default: '',
+  },
+});
+
+const { t } = useI18n();
+const route = useRoute();
+const router = useRouter();
+const { isCloudFeatureEnabled } = useAccount();
+
+const uiFlags = useMapGetter('captainAssistants/getUIFlags');
+const isFetching = computed(() => uiFlags.value.fetchingItem);
+
+const isCaptainV2Enabled = computed(() =>
+  isCloudFeatureEnabled(FEATURE_FLAGS.CAPTAIN_V2)
+);
+
+const tabs = computed(() => {
+  const items = [
+    {
+      id: 'captain_assistants_settings_index',
+      icon: 'i-lucide-settings',
+      label: t('CAPTAIN.ASSISTANTS.SETTINGS.BASIC_SETTINGS.TITLE'),
+    },
+    {
+      id: 'captain_assistants_settings_system_index',
+      icon: 'i-lucide-sliders-horizontal',
+      label: t('CAPTAIN.ASSISTANTS.SETTINGS.SYSTEM_SETTINGS.TITLE'),
+    },
+    {
+      id: 'captain_assistants_settings_audience_index',
+      icon: 'i-lucide-users',
+      label: t('CAPTAIN.ASSISTANTS.SETTINGS.AUDIENCE.TITLE'),
+    },
+    {
+      id: 'captain_assistants_settings_schedule_index',
+      icon: 'i-lucide-calendar-clock',
+      label: t('CAPTAIN.ASSISTANTS.SETTINGS.SCHEDULE.TITLE'),
+    },
+  ];
+
+  if (isCaptainV2Enabled.value) {
+    items.push(
+      {
+        id: 'captain_assistants_guardrails_index',
+        icon: 'i-lucide-shield-check',
+        label: t(
+          'CAPTAIN.ASSISTANTS.SETTINGS.CONTROL_ITEMS.OPTIONS.GUARDRAILS.TITLE'
+        ),
+      },
+      {
+        id: 'captain_assistants_guidelines_index',
+        icon: 'i-lucide-message-square-text',
+        label: t(
+          'CAPTAIN.ASSISTANTS.SETTINGS.CONTROL_ITEMS.OPTIONS.RESPONSE_GUIDELINES.TITLE'
+        ),
+      }
+    );
+  }
+
+  return items;
+});
+
+const activeTab = computed({
+  get: () => route.name,
+  set: name =>
+    router.push({
+      name,
+      params: {
+        accountId: route.params.accountId,
+        assistantId: route.params.assistantId,
+      },
+    }),
+});
+</script>
+
+<template>
+  <PageLayout
+    :header-title="t('CAPTAIN.ASSISTANTS.SETTINGS.HEADER')"
+    :is-fetching="isFetching"
+    :show-know-more="false"
+    :show-pagination-footer="false"
+  >
+    <template #body>
+      <VerticalTabs
+        v-model="activeTab"
+        :tabs="tabs"
+        content-class="max-w-[45rem] pb-8"
+      >
+        <template #[activeTab]>
+          <div class="flex flex-col w-full gap-6">
+            <SettingsHeader :heading="heading" :description="description" />
+            <slot />
+          </div>
+        </template>
+      </VerticalTabs>
+    </template>
+  </PageLayout>
+</template>
diff --git a/app/javascript/dashboard/components-next/captain/pageComponents/assistant/settings/audience/AudienceGroup.vue b/app/javascript/dashboard/components-next/captain/pageComponents/assistant/settings/audience/AudienceGroup.vue
new file mode 100644
index 000000000..9b6cf1f28
--- /dev/null
+++ b/app/javascript/dashboard/components-next/captain/pageComponents/assistant/settings/audience/AudienceGroup.vue
@@ -0,0 +1,167 @@
+<script setup>
+import { useTemplateRef } from 'vue';
+import { useI18n } from 'vue-i18n';
+import Button from 'next/button/Button.vue';
+import FilterSelect from 'dashboard/components-next/filter/inputs/FilterSelect.vue';
+import ConditionRow from 'dashboard/components-next/filter/ConditionRow.vue';
+
+const props = defineProps({
+  filterTypes: { type: Array, required: true },
+  depth: { type: Number, default: 0 },
+  maxDepth: { type: Number, default: 1 },
+  isRoot: { type: Boolean, default: false },
+});
+
+const emit = defineEmits(['remove']);
+
+const node = defineModel({ type: Object, required: true });
+
+const { t } = useI18n();
+
+let uid = 0;
+const nextId = () => {
+  uid += 1;
+  return `audience-${Date.now()}-${uid}`;
+};
+
+const DEFAULT_LEAF = () => ({
+  id: nextId(),
+  attributeKey: 'email',
+  filterOperator: 'contains',
+  values: '',
+  attributeModel: 'standard',
+});
+
+const operatorOptions = [
+  { value: 'and', label: t('CAPTAIN.ASSISTANTS.FORM.AUDIENCE.MATCH_ALL') },
+  { value: 'or', label: t('CAPTAIN.ASSISTANTS.FORM.AUDIENCE.MATCH_ANY') },
+];
+
+const isGroup = child =>
+  Object.prototype.hasOwnProperty.call(child, 'conditions');
+
+const addCondition = () => {
+  node.value.conditions.push(DEFAULT_LEAF());
+};
+
+const addGroup = () => {
+  node.value.conditions.push({
+    id: nextId(),
+    operator: 'and',
+    conditions: [DEFAULT_LEAF()],
+  });
+};
+
+const removeChild = index => {
+  node.value.conditions.splice(index, 1);
+  // A nested group must always hold at least one condition; remove the whole group when emptied.
+  if (!props.isRoot && node.value.conditions.length === 0) {
+    emit('remove');
+  }
+};
+
+const leafRefs = useTemplateRef('leafRefs');
+const groupRefs = useTemplateRef('groupRefs');
+
+const validate = () => {
+  const leavesValid = (leafRefs.value ?? []).every(row => row.validate());
+  const groupsValid = (groupRefs.value ?? []).every(group => group.validate());
+  return leavesValid && groupsValid;
+};
+
+defineExpose({ validate });
+</script>
+
+<template>
+  <div
+    class="flex flex-col gap-4 group/audience-group"
+    :class="
+      isRoot
+        ? 'p-4 border border-n-weak rounded-xl'
+        : 'p-3 border border-n-weak bg-n-alpha-1 rounded-lg'
+    "
+  >
+    <div class="flex items-center gap-2">
+      <div class="flex items-center gap-1.5 text-sm text-n-slate-11">
+        <span>{{ t('CAPTAIN.ASSISTANTS.FORM.AUDIENCE.MATCH_PREFIX') }}</span>
+        <FilterSelect
+          v-model="node.operator"
+          variant="faded"
+          hide-icon
+          class="text-sm"
+          :options="operatorOptions"
+        />
+        <span>{{ t('CAPTAIN.ASSISTANTS.FORM.AUDIENCE.MATCH_SUFFIX') }}</span>
+      </div>
+      <Button
+        v-if="!isRoot"
+        sm
+        ghost
+        slate
+        icon="i-lucide-trash"
+        class="ml-auto flex-shrink-0 opacity-0 transition-opacity group-hover/audience-group:opacity-100"
+        @click="emit('remove')"
+      />
+    </div>
+
+    <ul class="grid gap-3 list-none">
+      <template v-for="(child, index) in node.conditions" :key="child.id">
+        <AudienceGroup
+          v-if="isGroup(child)"
+          ref="groupRefs"
+          v-model="node.conditions[index]"
+          :filter-types="filterTypes"
+          :depth="depth + 1"
+          :max-depth="maxDepth"
+          @remove="removeChild(index)"
+        />
+        <ConditionRow
+          v-else
+          ref="leafRefs"
+          v-model:attribute-key="child.attributeKey"
+          v-model:filter-operator="child.filterOperator"
+          v-model:values="child.values"
+          :filter-types="filterTypes"
+          :show-query-operator="false"
+          searchable-attributes
+          @remove="removeChild(index)"
+        />
+      </template>
+    </ul>
+
+    <div
+      v-if="isRoot && !node.conditions.length"
+      class="flex flex-col items-center gap-1.5 px-4 py-8 text-center border border-dashed rounded-lg border-n-strong"
+    >
+      <span class="text-2xl i-lucide-users-round text-n-slate-10" />
+      <p class="text-sm font-medium text-n-slate-12">
+        {{ t('CAPTAIN.ASSISTANTS.FORM.AUDIENCE.EMPTY_TITLE') }}
+      </p>
+      <p class="max-w-md text-sm text-n-slate-11">
+        {{ t('CAPTAIN.ASSISTANTS.FORM.AUDIENCE.EMPTY_BODY') }}
+      </p>
+    </div>
+
+    <div class="flex gap-2">
+      <Button
+        sm
+        ghost
+        blue
+        icon="i-lucide-plus"
+        class="flex-shrink-0"
+        :label="t('CAPTAIN.ASSISTANTS.FORM.AUDIENCE.ADD_CONDITION')"
+        @click="addCondition"
+      />
+      <Button
+        v-if="depth < maxDepth"
+        sm
+        ghost
+        blue
+        icon="i-lucide-plus"
+        class="flex-shrink-0"
+        :label="t('CAPTAIN.ASSISTANTS.FORM.AUDIENCE.ADD_GROUP')"
+        @click="addGroup"
+      />
+    </div>
+  </div>
+</template>
diff --git a/app/javascript/dashboard/components-next/captain/pageComponents/assistant/settings/audience/useAudienceFilterTypes.js b/app/javascript/dashboard/components-next/captain/pageComponents/assistant/settings/audience/useAudienceFilterTypes.js
new file mode 100644
index 000000000..07b13d8d8
--- /dev/null
+++ b/app/javascript/dashboard/components-next/captain/pageComponents/assistant/settings/audience/useAudienceFilterTypes.js
@@ -0,0 +1,131 @@
+import { computed } from 'vue';
+import { useI18n } from 'vue-i18n';
+import { useMapGetter } from 'dashboard/composables/store.js';
+import { useContactFilterContext } from 'dashboard/components-next/filter/contactProvider.js';
+import { useOperators } from 'dashboard/components-next/filter/operators.js';
+import languages from 'dashboard/components/widgets/conversation/advancedFilterItems/languages.js';
+
+const STANDARD_ICONS = {
+  name: 'i-lucide-user',
+  email: 'i-lucide-mail',
+  phone_number: 'i-lucide-phone',
+  identifier: 'i-lucide-fingerprint',
+  country_code: 'i-lucide-flag',
+  city: 'i-lucide-map-pin',
+  company_name: 'i-lucide-building-2',
+  created_at: 'i-lucide-calendar',
+  last_activity_at: 'i-lucide-activity',
+  blocked: 'i-lucide-ban',
+  labels: 'i-lucide-tags',
+  hmac_verified: 'i-lucide-user-check',
+  browser_language: 'i-lucide-globe',
+};
+
+const CUSTOM_TYPE_ICONS = {
+  text: 'i-lucide-type',
+  number: 'i-lucide-hash',
+  currency: 'i-lucide-banknote',
+  percent: 'i-lucide-percent',
+  link: 'i-lucide-link',
+  date: 'i-lucide-calendar',
+  list: 'i-lucide-list',
+  checkbox: 'i-lucide-square-check',
+};
+
+const DEFAULT_ICON = 'i-lucide-tag';
+
+const header = (id, label) => ({
+  value: `__group_${id}`,
+  label,
+  disabled: true,
+});
+
+export function useAudienceFilterTypes() {
+  const { t } = useI18n();
+  const { filterTypes: contactFilterTypes } = useContactFilterContext();
+  const { equalityOperators } = useOperators();
+  const contactAttributes = useMapGetter('attributes/getContactAttributes');
+
+  const customTypeByKey = computed(() =>
+    Object.fromEntries(
+      (contactAttributes.value || []).map(attr => [
+        attr.attributeKey,
+        attr.attributeDisplayType,
+      ])
+    )
+  );
+
+  const conversationOption = (key, label, options) => ({
+    attributeKey: key,
+    value: key,
+    attributeName: label,
+    label,
+    icon: STANDARD_ICONS[key],
+    inputType: 'searchSelect',
+    options,
+    dataType: 'text',
+    filterOperators: equalityOperators.value,
+    attributeModel: 'additional',
+  });
+
+  const conversationTypes = computed(() => [
+    conversationOption(
+      'hmac_verified',
+      t('CAPTAIN.ASSISTANTS.FORM.AUDIENCE.LOGGED_IN'),
+      [
+        {
+          id: 'true',
+          name: t('CAPTAIN.ASSISTANTS.FORM.AUDIENCE.LOGGED_IN_TRUE'),
+        },
+        {
+          id: 'false',
+          name: t('CAPTAIN.ASSISTANTS.FORM.AUDIENCE.LOGGED_IN_FALSE'),
+        },
+      ]
+    ),
+    conversationOption(
+      'browser_language',
+      t('CAPTAIN.ASSISTANTS.FORM.AUDIENCE.BROWSER_LANGUAGE'),
+      languages
+    ),
+  ]);
+
+  const standardTypes = computed(() =>
+    contactFilterTypes.value
+      .filter(type => type.attributeModel !== 'customAttributes')
+      .map(type => ({
+        ...type,
+        icon: STANDARD_ICONS[type.attributeKey] || DEFAULT_ICON,
+      }))
+  );
+
+  const customTypes = computed(() =>
+    contactFilterTypes.value
+      .filter(type => type.attributeModel === 'customAttributes')
+      .filter(type => type.attributeKey in customTypeByKey.value)
+      .map(type => ({
+        ...type,
+        icon:
+          CUSTOM_TYPE_ICONS[customTypeByKey.value[type.attributeKey]] ||
+          DEFAULT_ICON,
+      }))
+  );
+
+  const filterTypes = computed(() => [
+    header('contact', t('CAPTAIN.ASSISTANTS.FORM.AUDIENCE.GROUP_CONTACT')),
+    ...standardTypes.value,
+    header(
+      'conversation',
+      t('CAPTAIN.ASSISTANTS.FORM.AUDIENCE.GROUP_CONVERSATION')
+    ),
+    ...conversationTypes.value,
+    ...(customTypes.value.length
+      ? [
+          header('custom', t('CAPTAIN.ASSISTANTS.FORM.AUDIENCE.GROUP_CUSTOM')),
+          ...customTypes.value,
+        ]
+      : []),
+  ]);
+
+  return { filterTypes };
+}
diff --git a/app/javascript/dashboard/components-next/captain/pageComponents/assistant/settings/audience/useAudienceFilterTypes.spec.js b/app/javascript/dashboard/components-next/captain/pageComponents/assistant/settings/audience/useAudienceFilterTypes.spec.js
new file mode 100644
index 000000000..0818d9264
--- /dev/null
+++ b/app/javascript/dashboard/components-next/captain/pageComponents/assistant/settings/audience/useAudienceFilterTypes.spec.js
@@ -0,0 +1,98 @@
+import languages from 'dashboard/components/widgets/conversation/advancedFilterItems/languages.js';
+import { useAudienceFilterTypes } from './useAudienceFilterTypes';
+
+const state = vi.hoisted(() => ({
+  contactFilterTypes: [],
+  contactAttributes: [],
+  equalityOperators: [{ value: 'equal_to' }, { value: 'not_equal_to' }],
+}));
+
+vi.mock('vue-i18n', () => ({
+  useI18n: () => ({ t: key => key }),
+}));
+
+vi.mock('dashboard/composables/store.js', () => ({
+  useMapGetter: () => ({ value: state.contactAttributes }),
+}));
+
+vi.mock('dashboard/components-next/filter/contactProvider.js', () => ({
+  useContactFilterContext: () => ({
+    filterTypes: { value: state.contactFilterTypes },
+  }),
+}));
+
+vi.mock('dashboard/components-next/filter/operators.js', () => ({
+  useOperators: () => ({
+    equalityOperators: { value: state.equalityOperators },
+  }),
+}));
+
+describe('useAudienceFilterTypes', () => {
+  beforeEach(() => {
+    state.contactFilterTypes = [
+      { attributeKey: 'email', attributeModel: 'standard' },
+      { attributeKey: 'mystery', attributeModel: 'standard' },
+      { attributeKey: 'signed_up_on', attributeModel: 'customAttributes' },
+      { attributeKey: 'company_size', attributeModel: 'customAttributes' },
+    ];
+    state.contactAttributes = [
+      { attributeKey: 'signed_up_on', attributeDisplayType: 'date' },
+    ];
+  });
+
+  const build = () => useAudienceFilterTypes().filterTypes.value;
+
+  it('assembles grouped sections in order', () => {
+    const keys = build().map(item => item.attributeKey ?? item.value);
+    expect(keys).toEqual([
+      '__group_contact',
+      'email',
+      'mystery',
+      '__group_conversation',
+      'hmac_verified',
+      'browser_language',
+      '__group_custom',
+      'signed_up_on',
+    ]);
+  });
+
+  it('marks headers as disabled options', () => {
+    const headers = build().filter(item => item.value?.startsWith('__group_'));
+    expect(headers).toHaveLength(3);
+    expect(headers.every(header => header.disabled)).toBe(true);
+  });
+
+  it('excludes custom attributes that are not contact-model attributes', () => {
+    const keys = build().map(item => item.attributeKey);
+    expect(keys).not.toContain('company_size');
+  });
+
+  it('omits the custom section when there are no contact custom attributes', () => {
+    state.contactAttributes = [];
+    const values = build().map(item => item.attributeKey ?? item.value);
+    expect(values).not.toContain('__group_custom');
+    expect(values).not.toContain('signed_up_on');
+  });
+
+  it('assigns icons by attribute key with a default fallback', () => {
+    const byKey = Object.fromEntries(
+      build().map(item => [item.attributeKey, item.icon])
+    );
+    expect(byKey.email).toBe('i-lucide-mail');
+    expect(byKey.mystery).toBe('i-lucide-tag');
+    expect(byKey.signed_up_on).toBe('i-lucide-calendar');
+  });
+
+  it('builds conversation options as searchSelects with equality operators', () => {
+    const types = build();
+    const hmac = types.find(item => item.attributeKey === 'hmac_verified');
+    expect(hmac.inputType).toBe('searchSelect');
+    expect(hmac.filterOperators).toEqual(state.equalityOperators);
+    expect(hmac.options.map(option => option.id)).toEqual(['true', 'false']);
+
+    const browserLanguage = types.find(
+      item => item.attributeKey === 'browser_language'
+    );
+    expect(browserLanguage.options).toEqual(languages);
+  });
+});
diff --git a/app/javascript/dashboard/components-next/filter/ConditionRow.vue b/app/javascript/dashboard/components-next/filter/ConditionRow.vue
index 30709babd..e28c744e0 100644
--- a/app/javascript/dashboard/components-next/filter/ConditionRow.vue
+++ b/app/javascript/dashboard/components-next/filter/ConditionRow.vue
@@ -15,6 +15,7 @@ import { validateSingleFilter } from 'dashboard/helper/validations.js';
 const { filterTypes } = defineProps({
   showQueryOperator: { type: Boolean, default: false },
   filterTypes: { type: Array, required: true },
+  searchableAttributes: { type: Boolean, default: false },
 });
 
 const emit = defineEmits(['remove']);
@@ -199,6 +200,7 @@ defineExpose({ validate, resetValidation });
         v-model="attributeKey"
         variant="faded"
         :options="filterTypes"
+        :searchable="searchableAttributes"
         @update:model-value="resetModelOnAttributeKeyChange"
       />
       <FilterSelect
diff --git a/app/javascript/dashboard/components-next/filter/contactProvider.js b/app/javascript/dashboard/components-next/filter/contactProvider.js
index 79933c138..21b5a9b14 100644
--- a/app/javascript/dashboard/components-next/filter/contactProvider.js
+++ b/app/javascript/dashboard/components-next/filter/contactProvider.js
@@ -165,16 +165,6 @@ export function useContactFilterContext() {
       filterOperators: dateOperators.value,
       attributeModel: 'standard',
     },
-    {
-      attributeKey: CONTACT_ATTRIBUTES.REFERER,
-      value: CONTACT_ATTRIBUTES.REFERER,
-      attributeName: t('CONTACTS_LAYOUT.FILTER.REFERER_LINK'),
-      label: t('CONTACTS_LAYOUT.FILTER.REFERER_LINK'),
-      inputType: 'plainText',
-      dataType: 'text',
-      filterOperators: containmentOperators.value,
-      attributeModel: 'standard',
-    },
     {
       attributeKey: CONTACT_ATTRIBUTES.BLOCKED,
       value: CONTACT_ATTRIBUTES.BLOCKED,
diff --git a/app/javascript/dashboard/components-next/filter/inputs/FilterSelect.vue b/app/javascript/dashboard/components-next/filter/inputs/FilterSelect.vue
index 58db5ecef..411ccd1b2 100644
--- a/app/javascript/dashboard/components-next/filter/inputs/FilterSelect.vue
+++ b/app/javascript/dashboard/components-next/filter/inputs/FilterSelect.vue
@@ -1,5 +1,6 @@
 <script setup>
 import { computed, ref } from 'vue';
+import { useI18n } from 'vue-i18n';
 import { useElementBounding, useWindowSize } from '@vueuse/core';
 import DropdownContainer from 'next/dropdown-menu/base/DropdownContainer.vue';
 import DropdownSection from 'next/dropdown-menu/base/DropdownSection.vue';
@@ -7,6 +8,7 @@ import DropdownBody from 'next/dropdown-menu/base/DropdownBody.vue';
 import DropdownItem from 'next/dropdown-menu/base/DropdownItem.vue';
 
 import Button from 'next/button/Button.vue';
+import Icon from 'next/icon/Icon.vue';
 
 // [{label, icon, value}]
 const props = defineProps({
@@ -30,6 +32,10 @@ const props = defineProps({
     type: String,
     default: null,
   },
+  searchable: {
+    type: Boolean,
+    default: false,
+  },
 });
 
 const selected = defineModel({
@@ -37,9 +43,23 @@ const selected = defineModel({
   required: true,
 });
 
+const vFocus = { mounted: el => el.focus() };
+
+const { t } = useI18n();
+
+const searchQuery = ref('');
 const triggerRef = ref(null);
 const dropdownRef = ref(null);
 
+const filteredOptions = computed(() => {
+  const query = searchQuery.value.trim().toLowerCase();
+  if (!props.searchable || !query) return props.options;
+  return props.options.filter(
+    option =>
+      !option.disabled && (option.label || '').toLowerCase().includes(query)
+  );
+});
+
 const { top } = useElementBounding(triggerRef);
 const { height } = useWindowSize();
 const { height: dropdownHeight } = useElementBounding(dropdownRef);
@@ -65,6 +85,12 @@ const dropdownPosition = computed(() => {
 
 const updateSelected = newValue => {
   selected.value = newValue;
+  searchQuery.value = '';
+};
+
+const handleTriggerClick = toggle => {
+  searchQuery.value = '';
+  toggle();
 };
 </script>
 
@@ -81,7 +107,7 @@ const updateSelected = newValue => {
           :icon="iconToRender"
           :trailing-icon="selectedOption.icon ? false : true"
           :label="label || (hideLabel ? null : selectedOption.label)"
-          @click="toggle"
+          @click="handleTriggerClick(toggle)"
         />
       </slot>
     </template>
@@ -91,8 +117,17 @@ const updateSelected = newValue => {
       :class="dropdownPosition"
       strong
     >
+      <div v-if="searchable" class="relative">
+        <Icon class="absolute size-4 left-2 top-2" icon="i-lucide-search" />
+        <input
+          v-model="searchQuery"
+          v-focus
+          class="w-full p-1.5 pl-8 rounded-lg text-n-slate-11 bg-n-alpha-1"
+          :placeholder="t('FILTER.SEARCH_PLACEHOLDER')"
+        />
+      </div>
       <DropdownSection class="[&>ul]:max-h-72">
-        <template v-for="option in options" :key="option.value">
+        <template v-for="option in filteredOptions" :key="option.value">
           <li
             v-if="option.disabled"
             class="px-2 py-1.5 text-xs font-medium text-n-slate-10 select-none"
@@ -106,6 +141,12 @@ const updateSelected = newValue => {
             @click="updateSelected(option.value)"
           />
         </template>
+        <li
+          v-if="searchable && !filteredOptions.length"
+          class="px-2 py-1.5 text-sm text-n-slate-10 select-none"
+        >
+          {{ t('FILTER.NO_RESULTS') }}
+        </li>
       </DropdownSection>
     </DropdownBody>
   </DropdownContainer>
diff --git a/app/javascript/dashboard/components-next/sidebar/Sidebar.vue b/app/javascript/dashboard/components-next/sidebar/Sidebar.vue
index eda659765..14e6e5ac6 100644
--- a/app/javascript/dashboard/components-next/sidebar/Sidebar.vue
+++ b/app/javascript/dashboard/components-next/sidebar/Sidebar.vue
@@ -562,6 +562,9 @@ const menuItems = computed(() => {
           label: t('SIDEBAR.CAPTAIN_SETTINGS'),
           activeOn: [
             'captain_assistants_settings_index',
+            'captain_assistants_settings_system_index',
+            'captain_assistants_settings_audience_index',
+            'captain_assistants_settings_schedule_index',
             'captain_assistants_guidelines_index',
             'captain_assistants_guardrails_index',
           ],
diff --git a/app/javascript/dashboard/i18n/locale/en/advancedFilters.json b/app/javascript/dashboard/i18n/locale/en/advancedFilters.json
index 89143c62a..ce72a1b13 100644
--- a/app/javascript/dashboard/i18n/locale/en/advancedFilters.json
+++ b/app/javascript/dashboard/i18n/locale/en/advancedFilters.json
@@ -19,6 +19,8 @@
       "OR": "OR"
     },
     "INPUT_PLACEHOLDER": "Enter value",
+    "SEARCH_PLACEHOLDER": "Search…",
+    "NO_RESULTS": "No matches",
     "CONTACT_SEARCH_PLACEHOLDER": "Search contacts",
     "CONTACT_FALLBACK": "Contact #{id}",
     "OPERATOR_LABELS": {
diff --git a/app/javascript/dashboard/i18n/locale/en/integrations.json b/app/javascript/dashboard/i18n/locale/en/integrations.json
index 2bb03746a..2ba6a8f7a 100644
--- a/app/javascript/dashboard/i18n/locale/en/integrations.json
+++ b/app/javascript/dashboard/i18n/locale/en/integrations.json
@@ -608,6 +608,48 @@
           "ALLOW_MEMORIES": "Capture key details as memories from customer interactions.",
           "ALLOW_CITATIONS": "Include source citations in responses",
           "ALLOW_CONTACT_ATTRIBUTES": "Allow access to contact information"
+        },
+        "AUDIENCE": {
+          "EVERYONE": {
+            "LABEL": "Everyone",
+            "DESC": "Captain responds to every conversation in connected inboxes."
+          },
+          "SPECIFIC": {
+            "LABEL": "Specific audience",
+            "DESC": "Captain responds only to customers who match the conditions below."
+          },
+          "ADD_CONDITION": "Add condition",
+          "ADD_GROUP": "Add condition group",
+          "EMPTY_TITLE": "No conditions yet",
+          "EMPTY_BODY": "Add a condition to target specific customers, or a condition group to combine conditions with different and/or logic.",
+          "EMPTY_ERROR": "Add at least one condition for a specific audience.",
+          "MATCH_PREFIX": "Match",
+          "MATCH_SUFFIX": "of the following",
+          "MATCH_ALL": "all",
+          "MATCH_ANY": "any",
+          "GROUP_CONTACT": "Contact attributes",
+          "GROUP_CONVERSATION": "Conversation",
+          "GROUP_CUSTOM": "Custom attributes",
+          "BROWSER_LANGUAGE": "Browser language",
+          "CONVERSATION_LANGUAGE": "First message language",
+          "LOGGED_IN": "Logged-in user",
+          "LOGGED_IN_TRUE": "Yes",
+          "LOGGED_IN_FALSE": "No"
+        },
+        "SCHEDULE": {
+          "ALWAYS": {
+            "LABEL": "Anytime",
+            "DESC": "Captain responds to every conversation, regardless of time."
+          },
+          "BUSINESS_HOURS": {
+            "LABEL": "During business hours",
+            "DESC": "Captain responds only within each inbox's business hours."
+          },
+          "OUTSIDE_BUSINESS_HOURS": {
+            "LABEL": "Outside business hours",
+            "DESC": "Captain responds only when each inbox is closed."
+          },
+          "HINT": "Inboxes without business hours configured are always covered."
         }
       },
       "EDIT": {
@@ -626,6 +668,14 @@
           "TITLE": "System settings",
           "DESCRIPTION": "Customize what the assistant says when ending a conversation or transferring to a human."
         },
+        "AUDIENCE": {
+          "TITLE": "Audience",
+          "DESCRIPTION": "Choose whether this assistant responds to everyone or only to a specific audience."
+        },
+        "SCHEDULE": {
+          "TITLE": "Schedule",
+          "DESCRIPTION": "Choose when Captain replies. Outside this window, conversations are handed to your team."
+        },
         "CONTROL_ITEMS": {
           "TITLE": "The Fun Stuff",
           "DESCRIPTION": "Add more control to the assistant. (a bit more visual like a story : Query guardrail → scenarios → output) Nudges user to actually utilise these.",
diff --git a/app/javascript/dashboard/routes/dashboard/captain/assistants/guardrails/Index.vue b/app/javascript/dashboard/routes/dashboard/captain/assistants/guardrails/Index.vue
index f61c2ed53..1903fadd8 100644
--- a/app/javascript/dashboard/routes/dashboard/captain/assistants/guardrails/Index.vue
+++ b/app/javascript/dashboard/routes/dashboard/captain/assistants/guardrails/Index.vue
@@ -1,17 +1,15 @@
 <script setup>
-import { computed, ref } from 'vue';
-import { useRoute } from 'vue-router';
+import { computed, ref, watch } from 'vue';
 import { useI18n } from 'vue-i18n';
 import { useAlert } from 'dashboard/composables';
 import { picoSearch } from '@scmmishra/pico-search';
 import { useStore } from 'dashboard/composables/store';
-import { useMapGetter } from 'dashboard/composables/store';
 import { useUISettings } from 'dashboard/composables/useUISettings';
+import { useAssistantSettings } from '../settings/useAssistantSettings';
 import Input from 'dashboard/components-next/input/Input.vue';
 import Button from 'dashboard/components-next/button/Button.vue';
 
-import PageLayout from 'dashboard/components-next/captain/PageLayout.vue';
-import SettingsHeader from 'dashboard/components-next/captain/pageComponents/settings/SettingsHeader.vue';
+import SettingsPageLayout from 'dashboard/components-next/captain/pageComponents/assistant/settings/SettingsPageLayout.vue';
 import SuggestedRules from 'dashboard/components-next/captain/assistant/SuggestedRules.vue';
 import AddNewRulesInput from 'dashboard/components-next/captain/assistant/AddNewRulesInput.vue';
 import AddNewRulesDialog from 'dashboard/components-next/captain/assistant/AddNewRulesDialog.vue';
@@ -19,16 +17,9 @@ import RuleCard from 'dashboard/components-next/captain/assistant/RuleCard.vue';
 import BulkSelectBar from 'dashboard/components-next/captain/assistant/BulkSelectBar.vue';
 
 const { t } = useI18n();
-const route = useRoute();
 const store = useStore();
 const { uiSettings, updateUISettings } = useUISettings();
-
-const uiFlags = useMapGetter('captainAssistants/getUIFlags');
-const assistantId = computed(() => Number(route.params.assistantId));
-const isFetching = computed(() => uiFlags.value.fetchingItem);
-const assistant = computed(() =>
-  store.getters['captainAssistants/getRecord'](assistantId.value)
-);
+const { assistantId, assistant } = useAssistantSettings();
 
 const searchQuery = ref('');
 const newInlineRule = ref('');
@@ -36,14 +27,6 @@ const newDialogRule = ref('');
 
 const guardrailsContent = computed(() => assistant.value?.guardrails || []);
 
-const backUrl = computed(() => ({
-  name: 'captain_assistants_settings_index',
-  params: {
-    accountId: route.params.accountId,
-    assistantId: assistantId.value,
-  },
-}));
-
 const displayGuardrails = computed(() =>
   guardrailsContent.value.map((c, idx) => ({ id: idx, content: c }))
 );
@@ -84,6 +67,11 @@ const closeSuggestedRules = () => {
 const bulkSelectedIds = ref(new Set());
 const hoveredCard = ref(null);
 
+watch(assistantId, () => {
+  bulkSelectedIds.value = new Set();
+  hoveredCard.value = null;
+});
+
 const handleRuleSelect = id => {
   const selected = new Set(bulkSelectedIds.value);
   selected[selected.has(id) ? 'delete' : 'add'](id);
@@ -173,130 +161,111 @@ const addAllExample = () => {
 </script>
 
 <template>
-  <PageLayout
-    :header-title="$t('CAPTAIN.ASSISTANTS.GUARDRAILS.TITLE')"
-    :is-fetching="isFetching"
-    :back-url="backUrl"
-    :show-know-more="false"
-    :show-pagination-footer="false"
-    :show-assistant-switcher="false"
+  <SettingsPageLayout
+    :heading="t('CAPTAIN.ASSISTANTS.GUARDRAILS.TITLE')"
+    :description="t('CAPTAIN.ASSISTANTS.GUARDRAILS.DESCRIPTION')"
   >
-    <template #body>
-      <SettingsHeader
-        :heading="$t('CAPTAIN.ASSISTANTS.GUARDRAILS.TITLE')"
-        :description="$t('CAPTAIN.ASSISTANTS.GUARDRAILS.DESCRIPTION')"
-      />
-      <div v-if="shouldShowSuggestedRules" class="flex mt-7 flex-col gap-4">
-        <SuggestedRules
-          :title="$t('CAPTAIN.ASSISTANTS.GUARDRAILS.ADD.SUGGESTED.TITLE')"
-          :items="guardrailsExample"
-          @add="addAllExample"
-          @close="closeSuggestedRules"
-        >
-          <template #default="{ item }">
-            <div class="flex items-center justify-between w-full">
-              <span class="text-sm text-n-slate-12">
-                {{ item.content }}
-              </span>
-              <Button
-                :label="
-                  $t('CAPTAIN.ASSISTANTS.GUARDRAILS.ADD.SUGGESTED.ADD_SINGLE')
-                "
-                ghost
-                xs
-                slate
-                class="!text-sm !text-n-slate-11 flex-shrink-0"
-                @click="addGuardrail(item.content)"
-              />
-            </div>
-          </template>
-        </SuggestedRules>
-      </div>
-      <div class="flex mt-7 flex-col gap-4">
-        <div class="flex justify-between items-center">
-          <BulkSelectBar
-            v-model="bulkSelectedIds"
-            :all-items="displayGuardrails"
-            :select-all-label="buildSelectedCountLabel"
-            :selected-count-label="selectedCountLabel"
-            :delete-label="
-              $t('CAPTAIN.ASSISTANTS.GUARDRAILS.BULK_ACTION.BULK_DELETE_BUTTON')
-            "
-            @bulk-delete="bulkDeleteGuardrails"
-          >
-            <template #default-actions>
-              <AddNewRulesDialog
-                v-model="newDialogRule"
-                :placeholder="
-                  t('CAPTAIN.ASSISTANTS.GUARDRAILS.ADD.NEW.PLACEHOLDER')
-                "
-                :button-label="t('CAPTAIN.ASSISTANTS.GUARDRAILS.ADD.NEW.TITLE')"
-                :confirm-label="
-                  t('CAPTAIN.ASSISTANTS.GUARDRAILS.ADD.NEW.CREATE')
-                "
-                :cancel-label="
-                  t('CAPTAIN.ASSISTANTS.GUARDRAILS.ADD.NEW.CANCEL')
-                "
-                @add="addGuardrail"
-              />
-              <!-- Will enable this feature in future -->
-              <!-- <div class="h-4 w-px bg-n-strong" />
-              <Button
-                :label="t('CAPTAIN.ASSISTANTS.GUARDRAILS.ADD.NEW.TEST_ALL')"
-                xs
-                ghost
-                slate
-                class="!text-sm"
-              /> -->
-            </template>
-          </BulkSelectBar>
-          <div
-            v-if="displayGuardrails.length && bulkSelectedIds.size === 0"
-            class="max-w-[22.5rem] w-full min-w-0"
-          >
-            <Input
-              v-model="searchQuery"
-              :placeholder="
-                t('CAPTAIN.ASSISTANTS.GUARDRAILS.LIST.SEARCH_PLACEHOLDER')
-              "
-            />
-          </div>
-        </div>
-        <div v-if="displayGuardrails.length === 0" class="mt-1 mb-2">
-          <span class="text-n-slate-11 text-sm">
-            {{ t('CAPTAIN.ASSISTANTS.GUARDRAILS.EMPTY_MESSAGE') }}
+    <SuggestedRules
+      v-if="shouldShowSuggestedRules"
+      :title="t('CAPTAIN.ASSISTANTS.GUARDRAILS.ADD.SUGGESTED.TITLE')"
+      :items="guardrailsExample"
+      @add="addAllExample"
+      @close="closeSuggestedRules"
+    >
+      <template #default="{ item }">
+        <div class="flex items-center justify-between w-full">
+          <span class="text-sm text-n-slate-12">
+            {{ item.content }}
           </span>
-        </div>
-        <div v-else-if="filteredGuardrails.length === 0" class="mt-1 mb-2">
-          <span class="text-n-slate-11 text-sm">
-            {{ t('CAPTAIN.ASSISTANTS.GUARDRAILS.SEARCH_EMPTY_MESSAGE') }}
-          </span>
-        </div>
-        <div v-else class="flex flex-col gap-2">
-          <RuleCard
-            v-for="guardrail in filteredGuardrails"
-            :id="guardrail.id"
-            :key="guardrail.id"
-            :content="guardrail.content"
-            :is-selected="bulkSelectedIds.has(guardrail.id)"
-            :selectable="
-              hoveredCard === guardrail.id || bulkSelectedIds.size > 0
-            "
-            @select="handleRuleSelect"
-            @edit="editGuardrail"
-            @delete="deleteGuardrail"
-            @hover="isHovered => handleRuleHover(isHovered, guardrail.id)"
+          <Button
+            :label="t('CAPTAIN.ASSISTANTS.GUARDRAILS.ADD.SUGGESTED.ADD_SINGLE')"
+            ghost
+            xs
+            slate
+            class="!text-sm !text-n-slate-11 flex-shrink-0"
+            @click="addGuardrail(item.content)"
           />
         </div>
-        <AddNewRulesInput
-          v-model="newInlineRule"
-          :placeholder="
-            t('CAPTAIN.ASSISTANTS.GUARDRAILS.ADD.SUGGESTED.PLACEHOLDER')
+      </template>
+    </SuggestedRules>
+    <div class="flex flex-col gap-4">
+      <div class="flex justify-between items-center">
+        <BulkSelectBar
+          v-model="bulkSelectedIds"
+          :all-items="displayGuardrails"
+          :select-all-label="buildSelectedCountLabel"
+          :selected-count-label="selectedCountLabel"
+          :delete-label="
+            t('CAPTAIN.ASSISTANTS.GUARDRAILS.BULK_ACTION.BULK_DELETE_BUTTON')
           "
-          :label="t('CAPTAIN.ASSISTANTS.GUARDRAILS.ADD.SUGGESTED.SAVE')"
-          @add="addGuardrail"
+          @bulk-delete="bulkDeleteGuardrails"
+        >
+          <template #default-actions>
+            <AddNewRulesDialog
+              v-model="newDialogRule"
+              :placeholder="
+                t('CAPTAIN.ASSISTANTS.GUARDRAILS.ADD.NEW.PLACEHOLDER')
+              "
+              :button-label="t('CAPTAIN.ASSISTANTS.GUARDRAILS.ADD.NEW.TITLE')"
+              :confirm-label="t('CAPTAIN.ASSISTANTS.GUARDRAILS.ADD.NEW.CREATE')"
+              :cancel-label="t('CAPTAIN.ASSISTANTS.GUARDRAILS.ADD.NEW.CANCEL')"
+              @add="addGuardrail"
+            />
+            <!-- Will enable this feature in future -->
+            <!-- <div class="h-4 w-px bg-n-strong" />
+            <Button
+              :label="t('CAPTAIN.ASSISTANTS.GUARDRAILS.ADD.NEW.TEST_ALL')"
+              xs
+              ghost
+              slate
+              class="!text-sm"
+            /> -->
+          </template>
+        </BulkSelectBar>
+        <div
+          v-if="displayGuardrails.length && bulkSelectedIds.size === 0"
+          class="max-w-[22.5rem] w-full min-w-0"
+        >
+          <Input
+            v-model="searchQuery"
+            :placeholder="
+              t('CAPTAIN.ASSISTANTS.GUARDRAILS.LIST.SEARCH_PLACEHOLDER')
+            "
+          />
+        </div>
+      </div>
+      <div v-if="displayGuardrails.length === 0" class="mt-1 mb-2">
+        <span class="text-n-slate-11 text-sm">
+          {{ t('CAPTAIN.ASSISTANTS.GUARDRAILS.EMPTY_MESSAGE') }}
+        </span>
+      </div>
+      <div v-else-if="filteredGuardrails.length === 0" class="mt-1 mb-2">
+        <span class="text-n-slate-11 text-sm">
+          {{ t('CAPTAIN.ASSISTANTS.GUARDRAILS.SEARCH_EMPTY_MESSAGE') }}
+        </span>
+      </div>
+      <div v-else class="flex flex-col gap-2">
+        <RuleCard
+          v-for="guardrail in filteredGuardrails"
+          :id="guardrail.id"
+          :key="guardrail.id"
+          :content="guardrail.content"
+          :is-selected="bulkSelectedIds.has(guardrail.id)"
+          :selectable="hoveredCard === guardrail.id || bulkSelectedIds.size > 0"
+          @select="handleRuleSelect"
+          @edit="editGuardrail"
+          @delete="deleteGuardrail"
+          @hover="isHovered => handleRuleHover(isHovered, guardrail.id)"
         />
       </div>
-    </template>
-  </PageLayout>
+      <AddNewRulesInput
+        v-model="newInlineRule"
+        :placeholder="
+          t('CAPTAIN.ASSISTANTS.GUARDRAILS.ADD.SUGGESTED.PLACEHOLDER')
+        "
+        :label="t('CAPTAIN.ASSISTANTS.GUARDRAILS.ADD.SUGGESTED.SAVE')"
+        @add="addGuardrail"
+      />
+    </div>
+  </SettingsPageLayout>
 </template>
diff --git a/app/javascript/dashboard/routes/dashboard/captain/assistants/guidelines/Index.vue b/app/javascript/dashboard/routes/dashboard/captain/assistants/guidelines/Index.vue
index 89aebd992..44c737275 100644
--- a/app/javascript/dashboard/routes/dashboard/captain/assistants/guidelines/Index.vue
+++ b/app/javascript/dashboard/routes/dashboard/captain/assistants/guidelines/Index.vue
@@ -1,17 +1,15 @@
 <script setup>
-import { computed, ref } from 'vue';
-import { useRoute } from 'vue-router';
+import { computed, ref, watch } from 'vue';
 import { useI18n } from 'vue-i18n';
 import { useAlert } from 'dashboard/composables';
 import { picoSearch } from '@scmmishra/pico-search';
 import { useStore } from 'dashboard/composables/store';
-import { useMapGetter } from 'dashboard/composables/store';
 import { useUISettings } from 'dashboard/composables/useUISettings';
+import { useAssistantSettings } from '../settings/useAssistantSettings';
 import Input from 'dashboard/components-next/input/Input.vue';
 import Button from 'dashboard/components-next/button/Button.vue';
 
-import PageLayout from 'dashboard/components-next/captain/PageLayout.vue';
-import SettingsHeader from 'dashboard/components-next/captain/pageComponents/settings/SettingsHeader.vue';
+import SettingsPageLayout from 'dashboard/components-next/captain/pageComponents/assistant/settings/SettingsPageLayout.vue';
 import SuggestedRules from 'dashboard/components-next/captain/assistant/SuggestedRules.vue';
 import AddNewRulesInput from 'dashboard/components-next/captain/assistant/AddNewRulesInput.vue';
 import AddNewRulesDialog from 'dashboard/components-next/captain/assistant/AddNewRulesDialog.vue';
@@ -19,16 +17,9 @@ import RuleCard from 'dashboard/components-next/captain/assistant/RuleCard.vue';
 import BulkSelectBar from 'dashboard/components-next/captain/assistant/BulkSelectBar.vue';
 
 const { t } = useI18n();
-const route = useRoute();
 const store = useStore();
 const { uiSettings, updateUISettings } = useUISettings();
-
-const uiFlags = useMapGetter('captainAssistants/getUIFlags');
-const assistantId = computed(() => Number(route.params.assistantId));
-const isFetching = computed(() => uiFlags.value.fetchingItem);
-const assistant = computed(() =>
-  store.getters['captainAssistants/getRecord'](assistantId.value)
-);
+const { assistantId, assistant } = useAssistantSettings();
 
 const searchQuery = ref('');
 const newInlineRule = ref('');
@@ -38,14 +29,6 @@ const guidelinesContent = computed(
   () => assistant.value?.response_guidelines || []
 );
 
-const backUrl = computed(() => ({
-  name: 'captain_assistants_settings_index',
-  params: {
-    accountId: route.params.accountId,
-    assistantId: assistantId.value,
-  },
-}));
-
 const displayGuidelines = computed(() =>
   guidelinesContent.value.map((c, idx) => ({ id: idx, content: c }))
 );
@@ -86,6 +69,11 @@ const closeSuggestedRules = () => {
 const bulkSelectedIds = ref(new Set());
 const hoveredCard = ref(null);
 
+watch(assistantId, () => {
+  bulkSelectedIds.value = new Set();
+  hoveredCard.value = null;
+});
+
 const handleRuleSelect = id => {
   const selected = new Set(bulkSelectedIds.value);
   selected[selected.has(id) ? 'delete' : 'add'](id);
@@ -180,147 +168,126 @@ const addAllExample = async () => {
 </script>
 
 <template>
-  <PageLayout
-    :header-title="$t('CAPTAIN.ASSISTANTS.RESPONSE_GUIDELINES.TITLE')"
-    :is-fetching="isFetching"
-    :back-url="backUrl"
-    :show-know-more="false"
-    :show-pagination-footer="false"
-    :show-assistant-switcher="false"
+  <SettingsPageLayout
+    :heading="t('CAPTAIN.ASSISTANTS.RESPONSE_GUIDELINES.TITLE')"
+    :description="t('CAPTAIN.ASSISTANTS.RESPONSE_GUIDELINES.DESCRIPTION')"
   >
-    <template #body>
-      <SettingsHeader
-        :heading="t('CAPTAIN.ASSISTANTS.RESPONSE_GUIDELINES.TITLE')"
-        :description="t('CAPTAIN.ASSISTANTS.RESPONSE_GUIDELINES.DESCRIPTION')"
-      />
-      <div v-if="shouldShowSuggestedRules" class="flex mt-7 flex-col gap-4">
-        <SuggestedRules
-          :title="t('CAPTAIN.ASSISTANTS.RESPONSE_GUIDELINES.TITLE')"
-          :items="guidelinesExample"
-          @add="addAllExample"
-          @close="closeSuggestedRules"
-        >
-          <template #default="{ item }">
-            <div class="flex items-center justify-between w-full">
-              <span class="text-sm text-n-slate-12">
-                {{ item.content }}
-              </span>
-              <Button
-                :label="
-                  t(
-                    'CAPTAIN.ASSISTANTS.RESPONSE_GUIDELINES.ADD.SUGGESTED.ADD_SINGLE'
-                  )
-                "
-                ghost
-                xs
-                slate
-                class="!text-sm !text-n-slate-11 flex-shrink-0"
-                @click="addGuideline(item.content)"
-              />
-            </div>
-          </template>
-        </SuggestedRules>
-      </div>
-      <div class="flex mt-7 flex-col gap-4">
-        <div class="flex justify-between items-center">
-          <BulkSelectBar
-            v-model="bulkSelectedIds"
-            :all-items="displayGuidelines"
-            :select-all-label="buildSelectedCountLabel"
-            :selected-count-label="selectedCountLabel"
-            :delete-label="
-              $t(
-                'CAPTAIN.ASSISTANTS.RESPONSE_GUIDELINES.BULK_ACTION.BULK_DELETE_BUTTON'
+    <SuggestedRules
+      v-if="shouldShowSuggestedRules"
+      :title="t('CAPTAIN.ASSISTANTS.RESPONSE_GUIDELINES.TITLE')"
+      :items="guidelinesExample"
+      @add="addAllExample"
+      @close="closeSuggestedRules"
+    >
+      <template #default="{ item }">
+        <div class="flex items-center justify-between w-full">
+          <span class="text-sm text-n-slate-12">
+            {{ item.content }}
+          </span>
+          <Button
+            :label="
+              t(
+                'CAPTAIN.ASSISTANTS.RESPONSE_GUIDELINES.ADD.SUGGESTED.ADD_SINGLE'
               )
             "
-            @bulk-delete="bulkDeleteGuidelines"
-          >
-            <template #default-actions>
-              <AddNewRulesDialog
-                v-model="newDialogRule"
-                :placeholder="
-                  t(
-                    'CAPTAIN.ASSISTANTS.RESPONSE_GUIDELINES.ADD.NEW.PLACEHOLDER'
-                  )
-                "
-                :button-label="
-                  t('CAPTAIN.ASSISTANTS.RESPONSE_GUIDELINES.ADD.NEW.TITLE')
-                "
-                :confirm-label="
-                  t('CAPTAIN.ASSISTANTS.RESPONSE_GUIDELINES.ADD.NEW.CREATE')
-                "
-                :cancel-label="
-                  t('CAPTAIN.ASSISTANTS.RESPONSE_GUIDELINES.ADD.NEW.CANCEL')
-                "
-                @add="addGuideline"
-              />
-              <!-- Will enable this feature in future -->
-              <!-- <div class="h-4 w-px bg-n-strong" />
-              <Button
-                :label="
-                  t('CAPTAIN.ASSISTANTS.RESPONSE_GUIDELINES.ADD.NEW.TEST_ALL')
-                "
-                sm
-                ghost
-                slate
-              /> -->
-            </template>
-          </BulkSelectBar>
-          <div
-            v-if="displayGuidelines.length && bulkSelectedIds.size === 0"
-            class="max-w-[22.5rem] w-full min-w-0"
-          >
-            <Input
-              v-model="searchQuery"
-              :placeholder="
-                t(
-                  'CAPTAIN.ASSISTANTS.RESPONSE_GUIDELINES.LIST.SEARCH_PLACEHOLDER'
-                )
-              "
-            />
-          </div>
-        </div>
-        <div v-if="displayGuidelines.length === 0" class="mt-1 mb-2">
-          <span class="text-n-slate-11 text-sm">
-            {{ t('CAPTAIN.ASSISTANTS.RESPONSE_GUIDELINES.EMPTY_MESSAGE') }}
-          </span>
-        </div>
-        <div v-else-if="filteredGuidelines.length === 0" class="mt-1 mb-2">
-          <span class="text-n-slate-11 text-sm">
-            {{
-              t('CAPTAIN.ASSISTANTS.RESPONSE_GUIDELINES.SEARCH_EMPTY_MESSAGE')
-            }}
-          </span>
-        </div>
-        <div v-else class="flex flex-col gap-2">
-          <RuleCard
-            v-for="guideline in filteredGuidelines"
-            :id="guideline.id"
-            :key="guideline.id"
-            :content="guideline.content"
-            :is-selected="bulkSelectedIds.has(guideline.id)"
-            :selectable="
-              hoveredCard === guideline.id || bulkSelectedIds.size > 0
-            "
-            @select="handleRuleSelect"
-            @hover="isHovered => handleRuleHover(isHovered, guideline.id)"
-            @edit="editGuideline"
-            @delete="deleteGuideline"
+            ghost
+            xs
+            slate
+            class="!text-sm !text-n-slate-11 flex-shrink-0"
+            @click="addGuideline(item.content)"
           />
         </div>
-        <AddNewRulesInput
-          v-model="newInlineRule"
-          :placeholder="
+      </template>
+    </SuggestedRules>
+    <div class="flex flex-col gap-4">
+      <div class="flex justify-between items-center">
+        <BulkSelectBar
+          v-model="bulkSelectedIds"
+          :all-items="displayGuidelines"
+          :select-all-label="buildSelectedCountLabel"
+          :selected-count-label="selectedCountLabel"
+          :delete-label="
             t(
-              'CAPTAIN.ASSISTANTS.RESPONSE_GUIDELINES.ADD.SUGGESTED.PLACEHOLDER'
+              'CAPTAIN.ASSISTANTS.RESPONSE_GUIDELINES.BULK_ACTION.BULK_DELETE_BUTTON'
             )
           "
-          :label="
-            t('CAPTAIN.ASSISTANTS.RESPONSE_GUIDELINES.ADD.SUGGESTED.SAVE')
-          "
-          @add="addGuideline"
+          @bulk-delete="bulkDeleteGuidelines"
+        >
+          <template #default-actions>
+            <AddNewRulesDialog
+              v-model="newDialogRule"
+              :placeholder="
+                t('CAPTAIN.ASSISTANTS.RESPONSE_GUIDELINES.ADD.NEW.PLACEHOLDER')
+              "
+              :button-label="
+                t('CAPTAIN.ASSISTANTS.RESPONSE_GUIDELINES.ADD.NEW.TITLE')
+              "
+              :confirm-label="
+                t('CAPTAIN.ASSISTANTS.RESPONSE_GUIDELINES.ADD.NEW.CREATE')
+              "
+              :cancel-label="
+                t('CAPTAIN.ASSISTANTS.RESPONSE_GUIDELINES.ADD.NEW.CANCEL')
+              "
+              @add="addGuideline"
+            />
+            <!-- Will enable this feature in future -->
+            <!-- <div class="h-4 w-px bg-n-strong" />
+            <Button
+              :label="
+                t('CAPTAIN.ASSISTANTS.RESPONSE_GUIDELINES.ADD.NEW.TEST_ALL')
+              "
+              sm
+              ghost
+              slate
+            /> -->
+          </template>
+        </BulkSelectBar>
+        <div
+          v-if="displayGuidelines.length && bulkSelectedIds.size === 0"
+          class="max-w-[22.5rem] w-full min-w-0"
+        >
+          <Input
+            v-model="searchQuery"
+            :placeholder="
+              t(
+                'CAPTAIN.ASSISTANTS.RESPONSE_GUIDELINES.LIST.SEARCH_PLACEHOLDER'
+              )
+            "
+          />
+        </div>
+      </div>
+      <div v-if="displayGuidelines.length === 0" class="mt-1 mb-2">
+        <span class="text-n-slate-11 text-sm">
+          {{ t('CAPTAIN.ASSISTANTS.RESPONSE_GUIDELINES.EMPTY_MESSAGE') }}
+        </span>
+      </div>
+      <div v-else-if="filteredGuidelines.length === 0" class="mt-1 mb-2">
+        <span class="text-n-slate-11 text-sm">
+          {{ t('CAPTAIN.ASSISTANTS.RESPONSE_GUIDELINES.SEARCH_EMPTY_MESSAGE') }}
+        </span>
+      </div>
+      <div v-else class="flex flex-col gap-2">
+        <RuleCard
+          v-for="guideline in filteredGuidelines"
+          :id="guideline.id"
+          :key="guideline.id"
+          :content="guideline.content"
+          :is-selected="bulkSelectedIds.has(guideline.id)"
+          :selectable="hoveredCard === guideline.id || bulkSelectedIds.size > 0"
+          @select="handleRuleSelect"
+          @hover="isHovered => handleRuleHover(isHovered, guideline.id)"
+          @edit="editGuideline"
+          @delete="deleteGuideline"
         />
       </div>
-    </template>
-  </PageLayout>
+      <AddNewRulesInput
+        v-model="newInlineRule"
+        :placeholder="
+          t('CAPTAIN.ASSISTANTS.RESPONSE_GUIDELINES.ADD.SUGGESTED.PLACEHOLDER')
+        "
+        :label="t('CAPTAIN.ASSISTANTS.RESPONSE_GUIDELINES.ADD.SUGGESTED.SAVE')"
+        @add="addGuideline"
+      />
+    </div>
+  </SettingsPageLayout>
 </template>
diff --git a/app/javascript/dashboard/routes/dashboard/captain/assistants/settings/Audience.vue b/app/javascript/dashboard/routes/dashboard/captain/assistants/settings/Audience.vue
new file mode 100644
index 000000000..9d44f7923
--- /dev/null
+++ b/app/javascript/dashboard/routes/dashboard/captain/assistants/settings/Audience.vue
@@ -0,0 +1,18 @@
+<script setup>
+import { useI18n } from 'vue-i18n';
+import { useAssistantSettings } from './useAssistantSettings';
+import SettingsPageLayout from 'dashboard/components-next/captain/pageComponents/assistant/settings/SettingsPageLayout.vue';
+import AssistantAudienceForm from 'dashboard/components-next/captain/pageComponents/assistant/settings/AssistantAudienceForm.vue';
+
+const { t } = useI18n();
+const { assistant, updateAssistant } = useAssistantSettings();
+</script>
+
+<template>
+  <SettingsPageLayout
+    :heading="t('CAPTAIN.ASSISTANTS.SETTINGS.AUDIENCE.TITLE')"
+    :description="t('CAPTAIN.ASSISTANTS.SETTINGS.AUDIENCE.DESCRIPTION')"
+  >
+    <AssistantAudienceForm :assistant="assistant" @submit="updateAssistant" />
+  </SettingsPageLayout>
+</template>
diff --git a/app/javascript/dashboard/routes/dashboard/captain/assistants/settings/Index.vue b/app/javascript/dashboard/routes/dashboard/captain/assistants/settings/Index.vue
new file mode 100644
index 000000000..b20b897aa
--- /dev/null
+++ b/app/javascript/dashboard/routes/dashboard/captain/assistants/settings/Index.vue
@@ -0,0 +1,91 @@
+<script setup>
+import { ref } from 'vue';
+import { useRoute, useRouter } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { useMapGetter } from 'dashboard/composables/store';
+import { useAssistantSettings } from './useAssistantSettings';
+import Button from 'dashboard/components-next/button/Button.vue';
+import SettingsPageLayout from 'dashboard/components-next/captain/pageComponents/assistant/settings/SettingsPageLayout.vue';
+import AssistantBasicSettingsForm from 'dashboard/components-next/captain/pageComponents/assistant/settings/AssistantBasicSettingsForm.vue';
+import DeleteDialog from 'dashboard/components-next/captain/pageComponents/DeleteDialog.vue';
+
+const { t } = useI18n();
+const route = useRoute();
+const router = useRouter();
+const { assistantId, assistant, updateAssistant } = useAssistantSettings();
+
+const deleteAssistantDialog = ref(null);
+const assistants = useMapGetter('captainAssistants/getRecords');
+
+const handleDelete = () => {
+  deleteAssistantDialog.value.dialogRef.open();
+};
+
+const handleDeleteSuccess = () => {
+  // Get remaining assistants after deletion
+  const remainingAssistants = assistants.value.filter(
+    a => a.id !== assistantId.value
+  );
+
+  if (remainingAssistants.length > 0) {
+    // Navigate to the first available assistant's settings
+    const nextAssistant = remainingAssistants[0];
+    router.push({
+      name: 'captain_assistants_settings_index',
+      params: {
+        accountId: route.params.accountId,
+        assistantId: nextAssistant.id,
+      },
+    });
+  } else {
+    // No assistants left, redirect to create assistant page
+    router.push({
+      name: 'captain_assistants_create_index',
+      params: { accountId: route.params.accountId },
+    });
+  }
+};
+</script>
+
+<template>
+  <SettingsPageLayout
+    :heading="t('CAPTAIN.ASSISTANTS.SETTINGS.BASIC_SETTINGS.TITLE')"
+    :description="t('CAPTAIN.ASSISTANTS.SETTINGS.BASIC_SETTINGS.DESCRIPTION')"
+  >
+    <AssistantBasicSettingsForm
+      :assistant="assistant"
+      @submit="updateAssistant"
+    />
+    <span class="w-full h-px mt-2 bg-n-weak" />
+    <div class="flex items-end justify-between w-full gap-4">
+      <div class="flex flex-col gap-2">
+        <h6 class="text-base font-medium text-n-slate-12">
+          {{ t('CAPTAIN.ASSISTANTS.SETTINGS.DELETE.TITLE') }}
+        </h6>
+        <span class="text-sm text-n-slate-11">
+          {{ t('CAPTAIN.ASSISTANTS.SETTINGS.DELETE.DESCRIPTION') }}
+        </span>
+      </div>
+      <div class="flex-shrink-0">
+        <Button
+          :label="
+            t('CAPTAIN.ASSISTANTS.SETTINGS.DELETE.BUTTON_TEXT', {
+              assistantName: assistant.name,
+            })
+          "
+          color="ruby"
+          class="max-w-56 !w-fit"
+          @click="handleDelete"
+        />
+      </div>
+    </div>
+    <DeleteDialog
+      v-if="assistant"
+      ref="deleteAssistantDialog"
+      :entity="assistant"
+      type="Assistants"
+      translation-key="ASSISTANTS"
+      @delete-success="handleDeleteSuccess"
+    />
+  </SettingsPageLayout>
+</template>
diff --git a/app/javascript/dashboard/routes/dashboard/captain/assistants/settings/Schedule.vue b/app/javascript/dashboard/routes/dashboard/captain/assistants/settings/Schedule.vue
new file mode 100644
index 000000000..547586564
--- /dev/null
+++ b/app/javascript/dashboard/routes/dashboard/captain/assistants/settings/Schedule.vue
@@ -0,0 +1,18 @@
+<script setup>
+import { useI18n } from 'vue-i18n';
+import { useAssistantSettings } from './useAssistantSettings';
+import SettingsPageLayout from 'dashboard/components-next/captain/pageComponents/assistant/settings/SettingsPageLayout.vue';
+import AssistantScheduleForm from 'dashboard/components-next/captain/pageComponents/assistant/settings/AssistantScheduleForm.vue';
+
+const { t } = useI18n();
+const { assistant, updateAssistant } = useAssistantSettings();
+</script>
+
+<template>
+  <SettingsPageLayout
+    :heading="t('CAPTAIN.ASSISTANTS.SETTINGS.SCHEDULE.TITLE')"
+    :description="t('CAPTAIN.ASSISTANTS.SETTINGS.SCHEDULE.DESCRIPTION')"
+  >
+    <AssistantScheduleForm :assistant="assistant" @submit="updateAssistant" />
+  </SettingsPageLayout>
+</template>
diff --git a/app/javascript/dashboard/routes/dashboard/captain/assistants/settings/Settings.vue b/app/javascript/dashboard/routes/dashboard/captain/assistants/settings/Settings.vue
deleted file mode 100644
index 7e667ffe9..000000000
--- a/app/javascript/dashboard/routes/dashboard/captain/assistants/settings/Settings.vue
+++ /dev/null
@@ -1,196 +0,0 @@
-<script setup>
-import { computed, ref } from 'vue';
-import { useRoute, useRouter } from 'vue-router';
-import { useI18n } from 'vue-i18n';
-import { useAlert } from 'dashboard/composables';
-import { useStore } from 'dashboard/composables/store';
-import { useMapGetter } from 'dashboard/composables/store';
-import { FEATURE_FLAGS } from 'dashboard/featureFlags';
-import { useAccount } from 'dashboard/composables/useAccount';
-import Button from 'dashboard/components-next/button/Button.vue';
-import PageLayout from 'dashboard/components-next/captain/PageLayout.vue';
-import SettingsHeader from 'dashboard/components-next/captain/pageComponents/settings/SettingsHeader.vue';
-import AssistantBasicSettingsForm from 'dashboard/components-next/captain/pageComponents/assistant/settings/AssistantBasicSettingsForm.vue';
-import AssistantSystemSettingsForm from 'dashboard/components-next/captain/pageComponents/assistant/settings/AssistantSystemSettingsForm.vue';
-import AssistantControlItems from 'dashboard/components-next/captain/pageComponents/assistant/settings/AssistantControlItems.vue';
-import DeleteDialog from 'dashboard/components-next/captain/pageComponents/DeleteDialog.vue';
-
-const { t } = useI18n();
-const { isCloudFeatureEnabled } = useAccount();
-
-const isCaptainV2Enabled = computed(() =>
-  isCloudFeatureEnabled(FEATURE_FLAGS.CAPTAIN_V2)
-);
-const route = useRoute();
-const router = useRouter();
-const store = useStore();
-
-const deleteAssistantDialog = ref(null);
-
-const uiFlags = useMapGetter('captainAssistants/getUIFlags');
-const assistants = useMapGetter('captainAssistants/getRecords');
-const isFetching = computed(() => uiFlags.value.fetchingItem);
-const assistantId = computed(() => Number(route.params.assistantId));
-const assistant = computed(() =>
-  store.getters['captainAssistants/getRecord'](assistantId.value)
-);
-
-const controlItems = computed(() => {
-  return [
-    {
-      name: t(
-        'CAPTAIN.ASSISTANTS.SETTINGS.CONTROL_ITEMS.OPTIONS.GUARDRAILS.TITLE'
-      ),
-      description: t(
-        'CAPTAIN.ASSISTANTS.SETTINGS.CONTROL_ITEMS.OPTIONS.GUARDRAILS.DESCRIPTION'
-      ),
-      routeName: 'captain_assistants_guardrails_index',
-    },
-    {
-      name: t(
-        'CAPTAIN.ASSISTANTS.SETTINGS.CONTROL_ITEMS.OPTIONS.RESPONSE_GUIDELINES.TITLE'
-      ),
-      description: t(
-        'CAPTAIN.ASSISTANTS.SETTINGS.CONTROL_ITEMS.OPTIONS.RESPONSE_GUIDELINES.DESCRIPTION'
-      ),
-      routeName: 'captain_assistants_guidelines_index',
-    },
-  ];
-});
-
-const handleSubmit = async updatedAssistant => {
-  try {
-    await store.dispatch('captainAssistants/update', {
-      id: assistantId.value,
-      ...updatedAssistant,
-    });
-    useAlert(t('CAPTAIN.ASSISTANTS.EDIT.SUCCESS_MESSAGE'));
-  } catch (error) {
-    const errorMessage =
-      error?.message || t('CAPTAIN.ASSISTANTS.EDIT.ERROR_MESSAGE');
-    useAlert(errorMessage);
-  }
-};
-
-const handleDelete = () => {
-  deleteAssistantDialog.value.dialogRef.open();
-};
-
-const handleDeleteSuccess = () => {
-  // Get remaining assistants after deletion
-  const remainingAssistants = assistants.value.filter(
-    a => a.id !== assistantId.value
-  );
-
-  if (remainingAssistants.length > 0) {
-    // Navigate to the first available assistant's settings
-    const nextAssistant = remainingAssistants[0];
-    router.push({
-      name: 'captain_assistants_settings_index',
-      params: {
-        accountId: route.params.accountId,
-        assistantId: nextAssistant.id,
-      },
-    });
-  } else {
-    // No assistants left, redirect to create assistant page
-    router.push({
-      name: 'captain_assistants_create_index',
-      params: { accountId: route.params.accountId },
-    });
-  }
-};
-</script>
-
-<template>
-  <PageLayout
-    :is-fetching="isFetching"
-    :show-pagination-footer="false"
-    :show-know-more="false"
-    :class="{
-      '[&>header>div]:max-w-[80rem] [&>main>div]:max-w-[80rem]':
-        isCaptainV2Enabled,
-    }"
-  >
-    <template #body>
-      <div
-        class="gap-6 lg:gap-16 pb-8"
-        :class="{ 'grid grid-cols-2': isCaptainV2Enabled }"
-      >
-        <div class="flex flex-col gap-6">
-          <div class="flex flex-col gap-6">
-            <SettingsHeader
-              :heading="t('CAPTAIN.ASSISTANTS.SETTINGS.BASIC_SETTINGS.TITLE')"
-              :description="
-                t('CAPTAIN.ASSISTANTS.SETTINGS.BASIC_SETTINGS.DESCRIPTION')
-              "
-            />
-            <AssistantBasicSettingsForm
-              :assistant="assistant"
-              @submit="handleSubmit"
-            />
-          </div>
-          <span class="h-px w-full bg-n-weak mt-2" />
-          <div class="flex flex-col gap-6">
-            <SettingsHeader
-              :heading="t('CAPTAIN.ASSISTANTS.SETTINGS.SYSTEM_SETTINGS.TITLE')"
-              :description="
-                t('CAPTAIN.ASSISTANTS.SETTINGS.SYSTEM_SETTINGS.DESCRIPTION')
-              "
-            />
-            <AssistantSystemSettingsForm
-              :assistant="assistant"
-              @submit="handleSubmit"
-            />
-          </div>
-          <span class="h-px w-full bg-n-weak mt-2" />
-          <div class="flex items-end justify-between w-full gap-4">
-            <div class="flex flex-col gap-2">
-              <h6 class="text-n-slate-12 text-base font-medium">
-                {{ t('CAPTAIN.ASSISTANTS.SETTINGS.DELETE.TITLE') }}
-              </h6>
-              <span class="text-n-slate-11 text-sm">
-                {{ t('CAPTAIN.ASSISTANTS.SETTINGS.DELETE.DESCRIPTION') }}
-              </span>
-            </div>
-            <div class="flex-shrink-0">
-              <Button
-                :label="
-                  t('CAPTAIN.ASSISTANTS.SETTINGS.DELETE.BUTTON_TEXT', {
-                    assistantName: assistant.name,
-                  })
-                "
-                color="ruby"
-                class="max-w-56 !w-fit"
-                @click="handleDelete"
-              />
-            </div>
-          </div>
-        </div>
-        <div v-if="isCaptainV2Enabled" class="flex flex-col gap-6">
-          <SettingsHeader
-            :heading="t('CAPTAIN.ASSISTANTS.SETTINGS.CONTROL_ITEMS.TITLE')"
-            :description="
-              t('CAPTAIN.ASSISTANTS.SETTINGS.CONTROL_ITEMS.DESCRIPTION')
-            "
-          />
-          <div class="flex flex-col gap-6">
-            <AssistantControlItems
-              v-for="item in controlItems"
-              :key="item.name"
-              :control-item="item"
-            />
-          </div>
-        </div>
-      </div>
-    </template>
-    <DeleteDialog
-      v-if="assistant"
-      ref="deleteAssistantDialog"
-      :entity="assistant"
-      type="Assistants"
-      translation-key="ASSISTANTS"
-      @delete-success="handleDeleteSuccess"
-    />
-  </PageLayout>
-</template>
diff --git a/app/javascript/dashboard/routes/dashboard/captain/assistants/settings/System.vue b/app/javascript/dashboard/routes/dashboard/captain/assistants/settings/System.vue
new file mode 100644
index 000000000..519b8937b
--- /dev/null
+++ b/app/javascript/dashboard/routes/dashboard/captain/assistants/settings/System.vue
@@ -0,0 +1,21 @@
+<script setup>
+import { useI18n } from 'vue-i18n';
+import { useAssistantSettings } from './useAssistantSettings';
+import SettingsPageLayout from 'dashboard/components-next/captain/pageComponents/assistant/settings/SettingsPageLayout.vue';
+import AssistantSystemSettingsForm from 'dashboard/components-next/captain/pageComponents/assistant/settings/AssistantSystemSettingsForm.vue';
+
+const { t } = useI18n();
+const { assistant, updateAssistant } = useAssistantSettings();
+</script>
+
+<template>
+  <SettingsPageLayout
+    :heading="t('CAPTAIN.ASSISTANTS.SETTINGS.SYSTEM_SETTINGS.TITLE')"
+    :description="t('CAPTAIN.ASSISTANTS.SETTINGS.SYSTEM_SETTINGS.DESCRIPTION')"
+  >
+    <AssistantSystemSettingsForm
+      :assistant="assistant"
+      @submit="updateAssistant"
+    />
+  </SettingsPageLayout>
+</template>
diff --git a/app/javascript/dashboard/routes/dashboard/captain/assistants/settings/useAssistantSettings.js b/app/javascript/dashboard/routes/dashboard/captain/assistants/settings/useAssistantSettings.js
new file mode 100644
index 000000000..adb1d0d17
--- /dev/null
+++ b/app/javascript/dashboard/routes/dashboard/captain/assistants/settings/useAssistantSettings.js
@@ -0,0 +1,31 @@
+import { computed } from 'vue';
+import { useRoute } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { useAlert } from 'dashboard/composables';
+import { useStore, useFunctionGetter } from 'dashboard/composables/store';
+
+export function useAssistantSettings() {
+  const { t } = useI18n();
+  const route = useRoute();
+  const store = useStore();
+
+  const assistantId = computed(() => Number(route.params.assistantId));
+  const assistant = useFunctionGetter(
+    'captainAssistants/getRecord',
+    assistantId
+  );
+
+  const updateAssistant = async updatedAssistant => {
+    try {
+      await store.dispatch('captainAssistants/update', {
+        id: assistantId.value,
+        ...updatedAssistant,
+      });
+      useAlert(t('CAPTAIN.ASSISTANTS.EDIT.SUCCESS_MESSAGE'));
+    } catch (error) {
+      useAlert(error?.message || t('CAPTAIN.ASSISTANTS.EDIT.ERROR_MESSAGE'));
+    }
+  };
+
+  return { assistantId, assistant, updateAssistant };
+}
diff --git a/app/javascript/dashboard/routes/dashboard/captain/assistants/settings/useAssistantSettings.spec.js b/app/javascript/dashboard/routes/dashboard/captain/assistants/settings/useAssistantSettings.spec.js
new file mode 100644
index 000000000..5a528ba39
--- /dev/null
+++ b/app/javascript/dashboard/routes/dashboard/captain/assistants/settings/useAssistantSettings.spec.js
@@ -0,0 +1,71 @@
+import { useAssistantSettings } from './useAssistantSettings';
+import { useStore, useFunctionGetter } from 'dashboard/composables/store';
+import { useAlert } from 'dashboard/composables';
+import { useRoute } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+
+vi.mock('dashboard/composables/store');
+vi.mock('dashboard/composables');
+vi.mock('vue-router');
+vi.mock('vue-i18n');
+
+describe('useAssistantSettings', () => {
+  const assistant = { id: 7, name: 'Support bot' };
+  const mockStore = { dispatch: vi.fn() };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    useStore.mockReturnValue(mockStore);
+    useFunctionGetter.mockReturnValue({ value: assistant });
+    useRoute.mockReturnValue({ params: { assistantId: '7' } });
+    useI18n.mockReturnValue({ t: key => key });
+  });
+
+  it('exposes the numeric assistant id from the route', () => {
+    expect(useAssistantSettings().assistantId.value).toBe(7);
+  });
+
+  it('reads the assistant from the store getter', () => {
+    const { assistant: record, assistantId } = useAssistantSettings();
+
+    expect(useFunctionGetter).toHaveBeenCalledWith(
+      'captainAssistants/getRecord',
+      assistantId
+    );
+    expect(record.value).toEqual(assistant);
+  });
+
+  it('dispatches the update with the assistant id and alerts success', async () => {
+    const { updateAssistant } = useAssistantSettings();
+
+    await updateAssistant({ config: { audience: null } });
+
+    expect(mockStore.dispatch).toHaveBeenCalledWith(
+      'captainAssistants/update',
+      { id: 7, config: { audience: null } }
+    );
+    expect(useAlert).toHaveBeenCalledWith(
+      'CAPTAIN.ASSISTANTS.EDIT.SUCCESS_MESSAGE'
+    );
+  });
+
+  it('alerts the error message when the update fails', async () => {
+    mockStore.dispatch.mockRejectedValueOnce(new Error('Audience is invalid'));
+    const { updateAssistant } = useAssistantSettings();
+
+    await updateAssistant({ name: 'New name' });
+
+    expect(useAlert).toHaveBeenCalledWith('Audience is invalid');
+  });
+
+  it('falls back to the generic error message when the error has none', async () => {
+    mockStore.dispatch.mockRejectedValueOnce({});
+    const { updateAssistant } = useAssistantSettings();
+
+    await updateAssistant({ name: 'New name' });
+
+    expect(useAlert).toHaveBeenCalledWith(
+      'CAPTAIN.ASSISTANTS.EDIT.ERROR_MESSAGE'
+    );
+  });
+});
diff --git a/app/javascript/dashboard/routes/dashboard/captain/captain.routes.js b/app/javascript/dashboard/routes/dashboard/captain/captain.routes.js
index b762394a0..c6666f149 100644
--- a/app/javascript/dashboard/routes/dashboard/captain/captain.routes.js
+++ b/app/javascript/dashboard/routes/dashboard/captain/captain.routes.js
@@ -11,7 +11,10 @@ import AssistantsIndexPage from './pages/AssistantsIndexPage.vue';
 import AssistantEmptyStateIndex from './assistants/Index.vue';
 
 import AssistantOverviewIndex from './assistants/overview/Index.vue';
-import AssistantSettingsIndex from './assistants/settings/Settings.vue';
+import AssistantSettingsIndex from './assistants/settings/Index.vue';
+import AssistantSystemSettingsIndex from './assistants/settings/System.vue';
+import AssistantAudienceSettingsIndex from './assistants/settings/Audience.vue';
+import AssistantScheduleSettingsIndex from './assistants/settings/Schedule.vue';
 import AssistantInboxesIndex from './assistants/inboxes/Index.vue';
 import AssistantPlaygroundIndex from './assistants/playground/Index.vue';
 import AssistantGuardrailsIndex from './assistants/guardrails/Index.vue';
@@ -110,7 +113,31 @@ const assistantRoutes = [
     name: 'captain_assistants_settings_index',
     meta,
   },
-  // Settings sub-pages (guardrails and guidelines)
+  // Settings sub-pages
+  {
+    path: frontendURL(
+      'accounts/:accountId/captain/:assistantId/settings/system'
+    ),
+    component: AssistantSystemSettingsIndex,
+    name: 'captain_assistants_settings_system_index',
+    meta,
+  },
+  {
+    path: frontendURL(
+      'accounts/:accountId/captain/:assistantId/settings/audience'
+    ),
+    component: AssistantAudienceSettingsIndex,
+    name: 'captain_assistants_settings_audience_index',
+    meta,
+  },
+  {
+    path: frontendURL(
+      'accounts/:accountId/captain/:assistantId/settings/schedule'
+    ),
+    component: AssistantScheduleSettingsIndex,
+    name: 'captain_assistants_settings_schedule_index',
+    meta,
+  },
   {
     path: frontendURL(
       'accounts/:accountId/captain/:assistantId/settings/guardrails'
diff --git a/enterprise/app/controllers/api/v1/accounts/captain/assistants_controller.rb b/enterprise/app/controllers/api/v1/accounts/captain/assistants_controller.rb
index f8291fdb8..da21c524c 100644
--- a/enterprise/app/controllers/api/v1/accounts/captain/assistants_controller.rb
+++ b/enterprise/app/controllers/api/v1/accounts/captain/assistants_controller.rb
@@ -127,7 +127,8 @@ class Api::V1::Accounts::Captain::AssistantsController < Api::V1::Accounts::Base
     assistant_config_attributes = [
       :product_name, :feature_faq, :feature_memory, :feature_citation,
       :feature_contact_attributes, :welcome_message, :handoff_message,
-      :resolution_message, :instructions, :temperature, :auto_resolve_mode
+      :resolution_message, :instructions, :temperature, :auto_resolve_mode,
+      :response_window
     ]
 
     permitted = params.require(:assistant).permit(:name, :description,
@@ -138,9 +139,21 @@ class Api::V1::Accounts::Captain::AssistantsController < Api::V1::Accounts::Base
 
     permitted[:guardrails] = params[:assistant][:guardrails] if params[:assistant].key?(:guardrails)
 
+    permit_audience_config(permitted)
+
     permitted
   end
 
+  # The audience is a recursive condition tree that strong params can't whitelist by shape;
+  # pass it through raw and let Captain::AudienceValidator enforce validity.
+  def permit_audience_config(permitted)
+    config = params[:assistant][:config]
+    return unless config.try(:key?, :audience)
+
+    audience = config[:audience]
+    permitted[:config][:audience] = audience.respond_to?(:permit!) ? audience.permit!.to_h : audience
+  end
+
   def playground_params
     params.require(:assistant).permit(:message_content, message_history: [:role, :content, :agent_name])
   end
diff --git a/enterprise/app/models/captain/assistant.rb b/enterprise/app/models/captain/assistant.rb
index 0149049ec..e8af11f90 100644
--- a/enterprise/app/models/captain/assistant.rb
+++ b/enterprise/app/models/captain/assistant.rb
@@ -20,6 +20,7 @@ class Captain::Assistant < ApplicationRecord
   DESCRIPTION_LENGTH_LIMIT = 500
   CITATION_SOURCES_STATE_KEY = :captain_v2_citation_sources
   AUTO_RESOLVE_MODES = %w[disabled legacy evaluated].freeze
+  RESPONSE_WINDOWS = %w[always business_hours outside_business_hours].freeze
 
   include Avatarable
   include Concerns::CaptainToolsHelpers
@@ -44,13 +45,15 @@ class Captain::Assistant < ApplicationRecord
   has_many :conversation_outcomes, dependent: :destroy_async
 
   store_accessor :config, :temperature, :feature_faq, :feature_memory, :feature_contact_attributes, :product_name,
-                 :auto_resolve_mode
+                 :auto_resolve_mode, :response_window
 
   before_validation :set_default_auto_resolve_mode, on: :create
 
   validates :name, presence: true
   validates :description, presence: true, length: { maximum: DESCRIPTION_LENGTH_LIMIT }
   validates :account_id, presence: true
+  validates_with Captain::AudienceValidator
+  validate :validate_response_window
   validates :auto_resolve_mode, inclusion: { in: AUTO_RESOLVE_MODES }
 
   scope :ordered, -> { order(created_at: :desc) }
@@ -61,6 +64,26 @@ class Captain::Assistant < ApplicationRecord
     name
   end
 
+  def engages?(contact, conversation)
+    responds_to_audience?(contact, conversation) && available_now?(conversation)
+  end
+
+  def responds_to_audience?(contact, conversation)
+    return true if config['audience'].blank?
+
+    Captain::AudienceMatcher.new(config['audience']).matches?(contact, conversation)
+  end
+
+  def available_now?(conversation)
+    response_window = config['response_window']
+    return true if response_window.blank? || response_window == 'always'
+
+    inbox = conversation.inbox
+    return true unless inbox.working_hours_enabled?
+
+    response_window == 'business_hours' ? !inbox.out_of_office? : inbox.out_of_office?
+  end
+
   def auto_resolve_mode
     config.fetch('auto_resolve_mode') { account&.captain_auto_resolve_mode || 'evaluated' }
   end
@@ -129,6 +152,13 @@ class Captain::Assistant < ApplicationRecord
 
   private
 
+  def validate_response_window
+    response_window = config['response_window']
+    return if response_window.blank?
+
+    errors.add(:config, 'invalid response_window') unless RESPONSE_WINDOWS.include?(response_window)
+  end
+
   def set_default_auto_resolve_mode
     return if config.key?('auto_resolve_mode')
 
diff --git a/enterprise/app/models/enterprise/conversation.rb b/enterprise/app/models/enterprise/conversation.rb
index f57aa3f05..c95f0615c 100644
--- a/enterprise/app/models/enterprise/conversation.rb
+++ b/enterprise/app/models/enterprise/conversation.rb
@@ -25,6 +25,15 @@ module Enterprise::Conversation
 
   private
 
+  def determine_conversation_status
+    super
+    return unless pending?
+    return if inbox.external_bot_active?
+
+    assistant = inbox.captain_assistant
+    self.status = :open if assistant.present? && !assistant.engages?(contact, self)
+  end
+
   def handle_resolved_status_change
     super
     update_applied_sla_completion
diff --git a/enterprise/app/models/enterprise/message.rb b/enterprise/app/models/enterprise/message.rb
index 11c65c6e5..a84b35d83 100644
--- a/enterprise/app/models/enterprise/message.rb
+++ b/enterprise/app/models/enterprise/message.rb
@@ -29,6 +29,15 @@ module Enterprise::Message
 
   private
 
+  def reopen_resolved_conversation
+    assistant = conversation.inbox.captain_assistant
+
+    return super if assistant.blank? || conversation.inbox.external_bot_active?
+    return conversation.open! unless assistant.engages?(conversation.contact, conversation)
+
+    super
+  end
+
   def mark_pending_conversation_as_open_for_human_response
     return unless captain_pending_conversation?
     return unless human_response?
diff --git a/enterprise/app/services/captain/audience_matcher.rb b/enterprise/app/services/captain/audience_matcher.rb
new file mode 100644
index 000000000..4546dbefa
--- /dev/null
+++ b/enterprise/app/services/captain/audience_matcher.rb
@@ -0,0 +1,180 @@
+# Evaluates an assistant's audience condition tree in-memory against the conversation's contact.
+# A node is either a group ({ operator:, conditions: [...] }) or a leaf
+# ({ attribute_key:, filter_operator:, values: [...] }). Operator semantics mirror
+# Contacts::FilterService so audiences match the same contacts as segments.
+class Captain::AudienceMatcher
+  CONTACT_STANDARD = %w[name email phone_number identifier blocked created_at last_activity_at].freeze
+  CONTACT_ADDITIONAL = %w[country_code city company_name].freeze
+  CONVERSATION_ADDITIONAL = %w[browser_language].freeze
+  OPERATORS = %w[equal_to not_equal_to contains does_not_contain is_present is_not_present starts_with
+                 is_greater_than is_less_than days_before].freeze
+  # Root group -> sub-group -> leaves.
+  MAX_DEPTH = 3
+
+  def initialize(audience)
+    @root = audience
+  end
+
+  def matches?(contact, conversation)
+    return true if @root.blank?
+
+    @contact = contact
+    @conversation = conversation
+    matches_node?(@root)
+  end
+
+  private
+
+  def matches_node?(node)
+    node = node.with_indifferent_access
+    node.key?(:conditions) ? matches_group?(node) : matches_leaf?(node)
+  end
+
+  def matches_group?(group)
+    conditions = Array(group[:conditions])
+    if group[:operator].to_s.casecmp?('or')
+      conditions.any? { |child| matches_node?(child) }
+    else
+      conditions.all? { |child| matches_node?(child) }
+    end
+  end
+
+  def matches_leaf?(leaf)
+    key = leaf[:attribute_key]
+    actual = attribute_value(key)
+    values = Array(leaf[:values])
+
+    case leaf[:filter_operator]
+    when 'is_present'     then actual.present?
+    when 'is_not_present' then actual.blank?
+    when 'equal_to'       then values.any? { |expected| value_equal?(key, actual, expected) }
+    when 'not_equal_to'   then negative_equality_match?(key, actual, values)
+    else matches_text_or_range?(leaf[:filter_operator], actual, values.first)
+    end
+  end
+
+  def attribute_value(key)
+    case key
+    when *CONTACT_STANDARD        then @contact[key]
+    when *CONTACT_ADDITIONAL      then @contact.additional_attributes[key]
+    when 'labels'                 then @contact.label_list
+    when *CONVERSATION_ADDITIONAL then @conversation.additional_attributes[key]
+    when 'hmac_verified'          then hmac_verified?
+    else @contact.custom_attributes[key]
+    end
+  end
+
+  def hmac_verified?
+    @conversation.contact_inbox&.hmac_verified || false
+  end
+
+  # labels is a has-tag check, booleans cast the expected string, phone numbers
+  # ignore the "+" prefix, and text compares case-insensitively.
+  def value_equal?(key, actual, expected)
+    return Array(actual).include?(expected) if key == 'labels'
+    return ActiveModel::Type::Boolean.new.cast(expected) == (actual == true) if boolean_condition?(key, actual, expected)
+    return numeric_equal?(actual, expected) if actual.is_a?(Numeric) || numeric_attribute?(key)
+
+    normalize(key, actual) == normalize(key, expected)
+  end
+
+  def numeric_equal?(actual, expected)
+    BigDecimal(actual.to_s) == BigDecimal(expected.to_s)
+  rescue ArgumentError, TypeError
+    false
+  end
+
+  def negative_equality_match?(key, actual, values)
+    if actual.nil?
+      custom_attribute = custom_attribute?(key)
+      return custom_attribute unless custom_attribute && checkbox_attribute?(key)
+    end
+
+    values.none? { |expected| value_equal?(key, actual, expected) }
+  end
+
+  def custom_attribute?(key)
+    CONTACT_STANDARD.exclude?(key) && CONTACT_ADDITIONAL.exclude?(key) && CONVERSATION_ADDITIONAL.exclude?(key) &&
+      %w[labels hmac_verified].exclude?(key)
+  end
+
+  # An unset checkbox attribute counts as false.
+  def boolean_condition?(key, actual, expected)
+    [true, false].include?(actual) ||
+      (actual.nil? && %w[true false].include?(expected.to_s) && checkbox_attribute?(key))
+  end
+
+  def checkbox_attribute?(key)
+    custom_attribute_types[key] == 'checkbox'
+  end
+
+  def numeric_attribute?(key)
+    %w[number currency percent].include?(custom_attribute_types[key])
+  end
+
+  def custom_attribute_types
+    @custom_attribute_types ||= @contact.account.custom_attribute_definitions.contact_attribute.each_with_object({}) do |definition, types|
+      types[definition.attribute_key] = definition.attribute_display_type
+    end
+  end
+
+  def normalize(key, value)
+    return value if value.nil?
+    return "+#{value.to_s.delete('+')}" if key == 'phone_number'
+
+    value.is_a?(String) ? value.downcase : value
+  end
+
+  def matches_text_or_range?(operator, actual, expected)
+    case operator
+    when 'contains'         then actual.to_s.downcase.include?(expected.to_s.downcase)
+    when 'does_not_contain' then excludes_text?(actual, expected)
+    when 'starts_with'      then actual.to_s.downcase.start_with?(expected.to_s.downcase)
+    when 'is_greater_than'  then compare(actual, expected) == 1
+    when 'is_less_than'     then compare(actual, expected) == -1
+    when 'days_before'      then older_than_days?(actual, expected)
+    else false
+    end
+  end
+
+  def excludes_text?(actual, expected)
+    !actual.nil? && actual.to_s.downcase.exclude?(expected.to_s.downcase)
+  end
+
+  # -1/0/1 like <=>, or nil when blank or unparseable (never matches).
+  def compare(actual, expected)
+    return nil if actual.blank?
+
+    actual = Time.zone.parse(actual) if iso_date_string?(actual)
+
+    if actual.is_a?(Date) || actual.acts_like?(:time)
+      expected_date = to_date(expected)
+      actual.to_date <=> expected_date if expected_date
+    else
+      BigDecimal(actual.to_s) <=> BigDecimal(expected.to_s)
+    end
+  rescue ArgumentError, TypeError
+    nil
+  end
+
+  # Custom date attributes store ISO strings in jsonb; treat them as dates the way
+  # Contacts::FilterService does (it casts them in SQL).
+  def iso_date_string?(value)
+    value.is_a?(String) && Date.iso8601(value).present?
+  rescue ArgumentError
+    false
+  end
+
+  def older_than_days?(actual, days)
+    date = to_date(actual)
+    date.present? && date < Time.zone.today - days.to_i.days
+  end
+
+  def to_date(value)
+    return value.to_date if value.respond_to?(:to_date)
+
+    Date.parse(value.to_s)
+  rescue ArgumentError, TypeError
+    nil
+  end
+end
diff --git a/enterprise/app/services/captain/conversation/response_scheduler_service.rb b/enterprise/app/services/captain/conversation/response_scheduler_service.rb
new file mode 100644
index 000000000..0e8f6c508
--- /dev/null
+++ b/enterprise/app/services/captain/conversation/response_scheduler_service.rb
@@ -0,0 +1,58 @@
+class Captain::Conversation::ResponseSchedulerService
+  MAX_ATTACHMENT_WAIT_SECONDS = 4
+
+  def initialize(message:)
+    @message = message
+    @conversation = message.conversation
+    @assistant = message.inbox.captain_assistant
+  end
+
+  def perform
+    track_captain_engagement
+
+    wait_time = attachment_wait_time
+    return Captain::Conversation::ResponseBuilderJob.perform_later(*job_args) if wait_time.zero?
+
+    Captain::Conversation::ResponseBuilderJob.set(wait: wait_time).perform_later(*job_args)
+  end
+
+  private
+
+  def job_args
+    args = [@conversation, @assistant]
+    args << @message.id if captain_v2_enabled?
+    args
+  end
+
+  def track_captain_engagement
+    return unless captain_v2_enabled?
+
+    Captain::ConversationEvents.engaged(
+      conversation: @conversation,
+      assistant: @assistant,
+      at: @message.created_at
+    )
+  end
+
+  def captain_v2_enabled?
+    @conversation.account.feature_enabled?('captain_integration_v2')
+  end
+
+  def attachment_wait_time
+    attachment_count = captain_v2_enabled? ? recent_attachment_count : @message.attachments.size
+    return 0.seconds if attachment_count.zero?
+
+    base_wait = 1.second
+    additional_wait = [attachment_count, MAX_ATTACHMENT_WAIT_SECONDS].min.seconds
+    base_wait + additional_wait
+  end
+
+  def recent_attachment_count
+    maximum_wait = (MAX_ATTACHMENT_WAIT_SECONDS + 1).seconds
+
+    @conversation.messages.incoming
+                 .joins(:attachments)
+                 .where(attachments: { created_at: maximum_wait.ago.. })
+                 .count
+  end
+end
diff --git a/enterprise/app/services/enterprise/message_templates/hook_execution_service.rb b/enterprise/app/services/enterprise/message_templates/hook_execution_service.rb
index b76dca06f..22997b0ca 100644
--- a/enterprise/app/services/enterprise/message_templates/hook_execution_service.rb
+++ b/enterprise/app/services/enterprise/message_templates/hook_execution_service.rb
@@ -1,13 +1,10 @@
 module Enterprise::MessageTemplates::HookExecutionService
-  MAX_ATTACHMENT_WAIT_SECONDS = 4
-
   def trigger_templates
     super
     return unless should_process_captain_response?
     return perform_handoff unless inbox.captain_active?
 
-    track_captain_engagement
-    schedule_captain_response
+    Captain::Conversation::ResponseSchedulerService.new(message: message).perform
   end
 
   def should_send_greeting?
@@ -30,59 +27,14 @@ module Enterprise::MessageTemplates::HookExecutionService
 
   private
 
-  def track_captain_engagement
-    return unless captain_v2_enabled?
-
-    Captain::ConversationEvents.engaged(
-      conversation: conversation,
-      assistant: inbox.captain_assistant,
-      at: message.created_at
-    )
-  end
-
   def captain_v2_enabled?
     conversation.account.feature_enabled?('captain_integration_v2')
   end
 
-  def schedule_captain_response
-    job_args = [conversation, conversation.inbox.captain_assistant]
-    captain_v2_enabled = conversation.account.feature_enabled?('captain_integration_v2')
-    job_args << message.id if captain_v2_enabled
-    wait_time = attachment_wait_time(captain_v2_enabled)
-
-    if wait_time.zero?
-      Captain::Conversation::ResponseBuilderJob.perform_later(*job_args)
-    else
-      Captain::Conversation::ResponseBuilderJob.set(wait: wait_time).perform_later(*job_args)
-    end
-  end
-
-  def attachment_wait_time(captain_v2_enabled)
-    attachment_count = captain_v2_enabled ? recent_attachment_count : message.attachments.size
-    return 0.seconds if attachment_count.zero?
-
-    calculate_attachment_wait_time(attachment_count)
-  end
-
-  def recent_attachment_count
-    maximum_wait = (MAX_ATTACHMENT_WAIT_SECONDS + 1).seconds
-
-    conversation.messages.incoming
-                .joins(:attachments)
-                .where(attachments: { created_at: maximum_wait.ago.. })
-                .count
-  end
-
-  def calculate_attachment_wait_time(attachment_count)
-    base_wait = 1.second
-
-    # Wait longer for more attachments or larger files
-    additional_wait = [attachment_count * 1, MAX_ATTACHMENT_WAIT_SECONDS].min.seconds
-    base_wait + additional_wait
-  end
-
   def should_process_captain_response?
-    conversation.pending? && message.captain_response_triggering? && inbox.captain_assistant.present? && !inbox.external_bot_active?
+    # Audience and schedule are decided when Captain first takes or reopens a conversation.
+    # Do not re-evaluate an existing pending conversation for each new message.
+    conversation.pending? && message.captain_response_triggering? && captain_assistant_configured? && !inbox.external_bot_active?
   end
 
   def perform_handoff
@@ -117,6 +69,10 @@ module Enterprise::MessageTemplates::HookExecutionService
   end
 
   def captain_handling_conversation?
-    conversation.pending? && inbox.respond_to?(:captain_assistant) && inbox.captain_assistant.present?
+    conversation.pending? && captain_assistant_configured?
+  end
+
+  def captain_assistant_configured?
+    inbox.captain_assistant.present?
   end
 end
diff --git a/enterprise/app/validators/captain/audience_validator.rb b/enterprise/app/validators/captain/audience_validator.rb
new file mode 100644
index 000000000..3236e8c1d
--- /dev/null
+++ b/enterprise/app/validators/captain/audience_validator.rb
@@ -0,0 +1,77 @@
+class Captain::AudienceValidator < ActiveModel::Validator
+  GROUP_OPERATORS = %w[and or].freeze
+  VALUELESS_OPERATORS = %w[is_present is_not_present].freeze
+  EQUALITY_OPERATORS = %w[equal_to not_equal_to].freeze
+  CONTAINMENT_OPERATORS = %w[equal_to not_equal_to contains does_not_contain].freeze
+  DATE_OPERATORS = %w[is_greater_than is_less_than days_before].freeze
+  COMPARISON_OPERATORS = %w[equal_to not_equal_to is_present is_not_present is_greater_than is_less_than].freeze
+
+  STANDARD_ATTRIBUTE_OPERATORS = {
+    'name' => EQUALITY_OPERATORS,
+    'email' => CONTAINMENT_OPERATORS,
+    'phone_number' => CONTAINMENT_OPERATORS,
+    'identifier' => EQUALITY_OPERATORS,
+    'blocked' => EQUALITY_OPERATORS,
+    'created_at' => DATE_OPERATORS,
+    'last_activity_at' => DATE_OPERATORS,
+    'country_code' => EQUALITY_OPERATORS,
+    'city' => CONTAINMENT_OPERATORS,
+    'company_name' => CONTAINMENT_OPERATORS,
+    'labels' => EQUALITY_OPERATORS,
+    'hmac_verified' => EQUALITY_OPERATORS,
+    'browser_language' => EQUALITY_OPERATORS
+  }.freeze
+
+  CUSTOM_ATTRIBUTE_OPERATORS = {
+    'text' => CONTAINMENT_OPERATORS,
+    'number' => EQUALITY_OPERATORS,
+    'currency' => EQUALITY_OPERATORS,
+    'percent' => EQUALITY_OPERATORS,
+    'link' => EQUALITY_OPERATORS,
+    'date' => COMPARISON_OPERATORS,
+    'list' => EQUALITY_OPERATORS,
+    'checkbox' => EQUALITY_OPERATORS
+  }.freeze
+
+  def validate(record)
+    audience = record.config['audience']
+    return if audience.blank?
+
+    custom_attribute_types = record.account.custom_attribute_definitions.contact_attribute.each_with_object({}) do |definition, types|
+      types[definition.attribute_key] = definition.attribute_display_type
+    end
+
+    record.errors.add(:config, 'audience must be a valid condition tree') unless valid_node?(audience, 1, custom_attribute_types)
+  end
+
+  private
+
+  def valid_node?(node, depth, custom_attribute_types)
+    return false unless node.is_a?(Hash) && depth <= Captain::AudienceMatcher::MAX_DEPTH
+
+    node = node.with_indifferent_access
+    return valid_group?(node, depth, custom_attribute_types) if node.key?(:conditions)
+
+    valid_leaf?(node, custom_attribute_types)
+  end
+
+  def valid_group?(node, depth, custom_attribute_types)
+    GROUP_OPERATORS.include?(node[:operator].to_s) &&
+      node[:conditions].is_a?(Array) &&
+      node[:conditions].present? &&
+      node[:conditions].all? { |child| valid_node?(child, depth + 1, custom_attribute_types) }
+  end
+
+  def valid_leaf?(node, custom_attribute_types)
+    operator = node[:filter_operator].to_s
+    allowed_operators = allowed_operators(node[:attribute_key].to_s, custom_attribute_types)
+    return false unless allowed_operators&.include?(operator)
+    return true if VALUELESS_OPERATORS.include?(operator)
+
+    node[:values].is_a?(Array) && node[:values].present? && node[:values].all? { |value| value.to_s.present? }
+  end
+
+  def allowed_operators(attribute_key, custom_attribute_types)
+    STANDARD_ATTRIBUTE_OPERATORS[attribute_key] || CUSTOM_ATTRIBUTE_OPERATORS[custom_attribute_types[attribute_key]]
+  end
+end
diff --git a/spec/enterprise/controllers/api/v1/accounts/captain/assistants_controller_spec.rb b/spec/enterprise/controllers/api/v1/accounts/captain/assistants_controller_spec.rb
index f30cda7d0..a539bcc2a 100644
--- a/spec/enterprise/controllers/api/v1/accounts/captain/assistants_controller_spec.rb
+++ b/spec/enterprise/controllers/api/v1/accounts/captain/assistants_controller_spec.rb
@@ -254,6 +254,47 @@ RSpec.describe 'Api::V1::Accounts::Captain::Assistants', type: :request do
         expect(response).to have_http_status(:success)
         expect(assistant.reload.config).to include('product_name' => 'Chatwoot', 'auto_resolve_mode' => 'disabled')
       end
+
+      it 'persists the nested audience condition tree' do
+        create(:custom_attribute_definition, account: account, attribute_model: :contact_attribute,
+                                             attribute_display_type: :text, attribute_key: 'plan_tier')
+        audience = {
+          operator: 'and',
+          conditions: [
+            { attribute_key: 'country_code', filter_operator: 'equal_to', values: ['US'] },
+            { operator: 'or', conditions: [
+              { attribute_key: 'plan_tier', filter_operator: 'equal_to', values: ['paid'] }
+            ] }
+          ]
+        }
+
+        patch "/api/v1/accounts/#{account.id}/captain/assistants/#{assistant.id}",
+              params: { assistant: { config: { audience: audience } } },
+              headers: admin.create_new_auth_token,
+              as: :json
+
+        expect(response).to have_http_status(:success)
+        stored = assistant.reload.config['audience']
+        expect(stored['operator']).to eq('and')
+        expect(stored['conditions'].first['attribute_key']).to eq('country_code')
+        expect(stored['conditions'].last['conditions'].first['values']).to eq(['paid'])
+      end
+
+      it 'rejects invalid audience attributes and operators' do
+        invalid_audiences = [
+          { attribute_key: 'missing_attribute', filter_operator: 'not_equal_to', values: ['known'] },
+          { attribute_key: 'blocked', filter_operator: 'is_not_present', values: [] }
+        ]
+
+        invalid_audiences.each do |audience|
+          patch "/api/v1/accounts/#{account.id}/captain/assistants/#{assistant.id}",
+                params: { assistant: { config: { audience: audience } } },
+                headers: admin.create_new_auth_token,
+                as: :json
+
+          expect(response).to have_http_status(:unprocessable_content)
+        end
+      end
     end
   end
 
diff --git a/spec/enterprise/models/captain/assistant_spec.rb b/spec/enterprise/models/captain/assistant_spec.rb
index e282124ae..177bb631d 100644
--- a/spec/enterprise/models/captain/assistant_spec.rb
+++ b/spec/enterprise/models/captain/assistant_spec.rb
@@ -1,10 +1,208 @@
 require 'rails_helper'
 
-RSpec.describe Captain::Assistant do
-  describe '#agent_tools' do
-    let(:account) { create(:account) }
-    let(:assistant) { create(:captain_assistant, account: account) }
+RSpec.describe Captain::Assistant, type: :model do
+  let(:account) { create(:account) }
+  let(:assistant) { create(:captain_assistant, account: account) }
+  let(:contact) { create(:contact, account: account, additional_attributes: { 'country_code' => 'US' }) }
+  let(:conversation) { create(:conversation, account: account, contact: contact) }
 
+  describe '#responds_to_audience?' do
+    it 'returns true when no audience is configured' do
+      expect(assistant.responds_to_audience?(contact, conversation)).to be(true)
+    end
+
+    it 'returns true when the contact matches the audience' do
+      assistant.update!(config: assistant.config.merge('audience' => {
+                                                         'attribute_key' => 'country_code', 'filter_operator' => 'equal_to', 'values' => ['US']
+                                                       }))
+      expect(assistant.responds_to_audience?(contact, conversation)).to be(true)
+    end
+
+    it 'returns false when the contact does not match the audience' do
+      assistant.update!(config: assistant.config.merge('audience' => {
+                                                         'attribute_key' => 'country_code', 'filter_operator' => 'equal_to', 'values' => ['CA']
+                                                       }))
+      expect(assistant.responds_to_audience?(contact, conversation)).to be(false)
+    end
+  end
+
+  describe '#available_now?' do
+    let(:inbox) { create(:inbox, account: account) }
+    let(:scheduled_conversation) { create(:conversation, account: account, inbox: inbox, contact: contact) }
+
+    it 'is available when the window is blank or always' do
+      expect(assistant.available_now?(scheduled_conversation)).to be(true)
+      assistant.config['response_window'] = 'always'
+      expect(assistant.available_now?(scheduled_conversation)).to be(true)
+    end
+
+    it 'is available regardless when the inbox has no business hours configured' do
+      inbox.update!(working_hours_enabled: false)
+      assistant.config['response_window'] = 'business_hours'
+      expect(assistant.available_now?(scheduled_conversation)).to be(true)
+    end
+
+    context 'when the inbox has business hours enabled' do
+      before { inbox.update!(working_hours_enabled: true) }
+
+      it 'business_hours matches only when the inbox is open' do
+        assistant.config['response_window'] = 'business_hours'
+        allow(scheduled_conversation.inbox).to receive(:out_of_office?).and_return(false)
+        expect(assistant.available_now?(scheduled_conversation)).to be(true)
+        allow(scheduled_conversation.inbox).to receive(:out_of_office?).and_return(true)
+        expect(assistant.available_now?(scheduled_conversation)).to be(false)
+      end
+
+      it 'outside_business_hours matches only when the inbox is closed' do
+        assistant.config['response_window'] = 'outside_business_hours'
+        allow(scheduled_conversation.inbox).to receive(:out_of_office?).and_return(true)
+        expect(assistant.available_now?(scheduled_conversation)).to be(true)
+        allow(scheduled_conversation.inbox).to receive(:out_of_office?).and_return(false)
+        expect(assistant.available_now?(scheduled_conversation)).to be(false)
+      end
+    end
+  end
+
+  describe 'response_window validation' do
+    it 'accepts a blank response_window' do
+      assistant.config['response_window'] = nil
+      expect(assistant).to be_valid
+    end
+
+    it 'accepts the known windows' do
+      described_class::RESPONSE_WINDOWS.each do |window|
+        assistant.config['response_window'] = window
+        expect(assistant).to be_valid
+      end
+    end
+
+    it 'rejects an unknown window' do
+      assistant.config['response_window'] = 'weekends'
+      expect(assistant).not_to be_valid
+      expect(assistant.errors[:config]).to include('invalid response_window')
+    end
+  end
+
+  describe 'audience validation' do
+    let(:leaf) { { 'attribute_key' => 'country_code', 'filter_operator' => 'equal_to', 'values' => ['US'] } }
+
+    it 'accepts a blank audience' do
+      assistant.config['audience'] = nil
+      expect(assistant).to be_valid
+    end
+
+    it 'accepts a single leaf' do
+      assistant.config['audience'] = leaf
+      expect(assistant).to be_valid
+    end
+
+    it 'accepts symbol keys' do
+      assistant.config['audience'] = { attribute_key: 'country_code', filter_operator: 'equal_to', values: ['US'] }
+      expect(assistant).to be_valid
+    end
+
+    it 'accepts a well-formed nested tree' do
+      assistant.config['audience'] = {
+        'operator' => 'and',
+        'conditions' => [
+          { 'operator' => 'or', 'conditions' => [leaf] },
+          leaf
+        ]
+      }
+      expect(assistant).to be_valid
+    end
+
+    it 'rejects a node that is not a hash' do
+      assistant.config['audience'] = ['not-a-node']
+      expect(assistant).not_to be_valid
+      expect(assistant.errors[:config]).to include('audience must be a valid condition tree')
+    end
+
+    it 'rejects an unknown operator' do
+      assistant.config['audience'] = leaf.merge('filter_operator' => 'bogus')
+      expect(assistant).not_to be_valid
+    end
+
+    it 'rejects an operator unsupported by a standard attribute' do
+      assistant.config['audience'] = leaf.merge('attribute_key' => 'blocked', 'filter_operator' => 'is_not_present', 'values' => [])
+      expect(assistant).not_to be_valid
+    end
+
+    it 'rejects a leaf missing attribute_key' do
+      assistant.config['audience'] = { 'filter_operator' => 'equal_to', 'values' => ['US'] }
+      expect(assistant).not_to be_valid
+    end
+
+    it 'rejects conversation language conditions' do
+      assistant.config['audience'] = {
+        'attribute_key' => 'conversation_language', 'filter_operator' => 'equal_to', 'values' => ['en']
+      }
+
+      expect(assistant).not_to be_valid
+    end
+
+    it 'rejects an unknown custom attribute' do
+      assistant.config['audience'] = {
+        'attribute_key' => 'missing_attribute', 'filter_operator' => 'not_equal_to', 'values' => ['known']
+      }
+
+      expect(assistant).not_to be_valid
+    end
+
+    it 'accepts an operator supported by a defined custom attribute' do
+      create(:custom_attribute_definition, account: account, attribute_model: :contact_attribute,
+                                           attribute_display_type: :date, attribute_key: 'signed_up_on')
+      assistant.config['audience'] = {
+        'attribute_key' => 'signed_up_on', 'filter_operator' => 'is_present', 'values' => []
+      }
+
+      expect(assistant).to be_valid
+    end
+
+    it 'rejects a group without conditions' do
+      assistant.config['audience'] = { 'operator' => 'and', 'conditions' => [] }
+      expect(assistant).not_to be_valid
+    end
+
+    it 'rejects an unknown group operator' do
+      assistant.config['audience'] = { 'operator' => 'xor', 'conditions' => [leaf] }
+      expect(assistant).not_to be_valid
+    end
+
+    it 'rejects a value-taking leaf without values' do
+      assistant.config['audience'] = { 'attribute_key' => 'email', 'filter_operator' => 'contains' }
+      expect(assistant).not_to be_valid
+    end
+
+    it 'rejects a valueless operator when the attribute does not support it' do
+      assistant.config['audience'] = { 'attribute_key' => 'email', 'filter_operator' => 'is_present' }
+      expect(assistant).not_to be_valid
+    end
+
+    it 'rejects conditions that is not an array' do
+      assistant.config['audience'] = { 'operator' => 'and', 'conditions' => leaf }
+      expect(assistant).not_to be_valid
+    end
+
+    it 'rejects a group containing an invalid child' do
+      assistant.config['audience'] = { 'operator' => 'and', 'conditions' => [leaf, { 'attribute_key' => '' }] }
+      expect(assistant).not_to be_valid
+    end
+
+    it 'rejects nesting deeper than one level' do
+      assistant.config['audience'] = {
+        'operator' => 'and',
+        'conditions' => [
+          { 'operator' => 'or', 'conditions' => [
+            { 'operator' => 'and', 'conditions' => [leaf] }
+          ] }
+        ]
+      }
+      expect(assistant).not_to be_valid
+    end
+  end
+
+  describe '#agent_tools' do
     it 'includes enabled custom tools from the assistant account' do
       custom_tool = create(:captain_custom_tool, account: account)
 
diff --git a/spec/enterprise/models/enterprise/conversation_spec.rb b/spec/enterprise/models/enterprise/conversation_spec.rb
new file mode 100644
index 000000000..b1cf87cb1
--- /dev/null
+++ b/spec/enterprise/models/enterprise/conversation_spec.rb
@@ -0,0 +1,28 @@
+require 'rails_helper'
+
+RSpec.describe Conversation, type: :model do
+  describe 'captain audience routing on create' do
+    let(:account) { create(:account) }
+    let(:inbox) { create(:inbox, account: account) }
+    let(:assistant) { create(:captain_assistant, account: account) }
+    let(:us_contact) { create(:contact, account: account, additional_attributes: { 'country_code' => 'US' }) }
+    let(:ca_contact) { create(:contact, account: account, additional_attributes: { 'country_code' => 'CA' }) }
+
+    before do
+      create(:captain_inbox, captain_assistant: assistant, inbox: inbox)
+      assistant.update!(config: assistant.config.merge('audience' => {
+                                                         'attribute_key' => 'country_code', 'filter_operator' => 'equal_to', 'values' => ['US']
+                                                       }))
+    end
+
+    it 'parks an in-audience contact conversation as pending' do
+      conversation = create(:conversation, account: account, inbox: inbox, contact: us_contact)
+      expect(conversation.status).to eq('pending')
+    end
+
+    it 'routes an out-of-audience contact conversation to open' do
+      conversation = create(:conversation, account: account, inbox: inbox, contact: ca_contact)
+      expect(conversation.status).to eq('open')
+    end
+  end
+end
diff --git a/spec/enterprise/services/captain/audience_matcher_spec.rb b/spec/enterprise/services/captain/audience_matcher_spec.rb
new file mode 100644
index 000000000..97b4209de
--- /dev/null
+++ b/spec/enterprise/services/captain/audience_matcher_spec.rb
@@ -0,0 +1,194 @@
+require 'rails_helper'
+
+RSpec.describe Captain::AudienceMatcher do
+  let(:account) { create(:account) }
+  let(:contact) do
+    create(:contact, :with_email, :with_phone_number, account: account,
+                                                      additional_attributes: { 'country_code' => 'US', 'city' => 'Boston', 'company_name' => 'Acme' },
+                                                      custom_attributes: { 'plan_tier' => 'paid' })
+  end
+  let(:conversation) do
+    create(:conversation, account: account, contact: contact,
+                          additional_attributes: { 'browser_language' => 'en' })
+  end
+
+  def leaf(attribute_key, filter_operator, values = nil)
+    { 'attribute_key' => attribute_key, 'filter_operator' => filter_operator, 'values' => Array(values) }
+  end
+
+  def matches?(audience)
+    described_class.new(audience).matches?(contact, conversation)
+  end
+
+  describe '#matches?' do
+    it 'returns true when the audience is blank' do
+      expect(matches?(nil)).to be(true)
+      expect(matches?({})).to be(true)
+    end
+
+    context 'with contact attribute leaves' do
+      it 'matches additional_attributes case-insensitively for country_code' do
+        expect(matches?(leaf('country_code', 'equal_to', 'us'))).to be(true)
+        expect(matches?(leaf('country_code', 'equal_to', 'ca'))).to be(false)
+      end
+
+      it 'matches custom attributes' do
+        expect(matches?(leaf('plan_tier', 'equal_to', 'paid'))).to be(true)
+        expect(matches?(leaf('plan_tier', 'not_equal_to', 'free'))).to be(true)
+      end
+
+      it 'compares numeric custom attribute values with UI strings' do
+        create(:custom_attribute_definition, account: account, attribute_model: :contact_attribute,
+                                             attribute_display_type: :number, attribute_key: 'annual_spend')
+        contact.update!(custom_attributes: contact.custom_attributes.merge('annual_spend' => 120.5))
+
+        expect(matches?(leaf('annual_spend', 'equal_to', '120.5'))).to be(true)
+        expect(matches?(leaf('annual_spend', 'equal_to', '120.6'))).to be(false)
+
+        contact.update!(custom_attributes: contact.custom_attributes.merge('annual_spend' => '120.50'))
+
+        expect(matches?(leaf('annual_spend', 'equal_to', '120.5'))).to be(true)
+        expect(matches?(leaf('annual_spend', 'not_equal_to', '120.5'))).to be(false)
+      end
+
+      it 'does not include missing standard and additional attributes in negative matches' do
+        contact.update!(email: 'person@chatwoot.com', identifier: nil,
+                        additional_attributes: contact.additional_attributes.except('country_code'))
+
+        expect(matches?(leaf('identifier', 'not_equal_to', 'known'))).to be(false)
+        expect(matches?(leaf('country_code', 'not_equal_to', 'US'))).to be(false)
+        expect(matches?(leaf('email', 'does_not_contain', 'example.com'))).to be(true)
+        expect(matches?(leaf('identifier', 'does_not_contain', 'known'))).to be(false)
+      end
+
+      it 'preserves custom attribute null semantics from contact filters' do
+        create(:custom_attribute_definition, account: account, attribute_model: :contact_attribute,
+                                             attribute_display_type: :text, attribute_key: 'missing_custom_attribute')
+        expect(matches?(leaf('missing_custom_attribute', 'not_equal_to', 'known'))).to be(true)
+        expect(matches?(leaf('missing_custom_attribute', 'does_not_contain', 'known'))).to be(false)
+      end
+
+      it 'matches checkbox custom attributes' do
+        contact.update!(custom_attributes: contact.custom_attributes.merge('newsletter_opt_in' => true))
+        expect(matches?(leaf('newsletter_opt_in', 'equal_to', 'true'))).to be(true)
+        expect(matches?(leaf('newsletter_opt_in', 'equal_to', 'false'))).to be(false)
+      end
+
+      it 'treats a missing checkbox attribute as false' do
+        create(:custom_attribute_definition, account: account, attribute_key: 'newsletter_opt_in',
+                                             attribute_model: 'contact_attribute', attribute_display_type: 'checkbox')
+
+        expect(matches?(leaf('newsletter_opt_in', 'equal_to', 'false'))).to be(true)
+        expect(matches?(leaf('newsletter_opt_in', 'equal_to', 'true'))).to be(false)
+        expect(matches?(leaf('newsletter_opt_in', 'not_equal_to', 'true'))).to be(true)
+        expect(matches?(leaf('newsletter_opt_in', 'not_equal_to', 'false'))).to be(false)
+      end
+
+      it 'supports contains / starts_with on text' do
+        expect(matches?(leaf('email', 'contains', contact.email[2..5]))).to be(true)
+        expect(matches?(leaf('city', 'starts_with', 'Bos'))).to be(true)
+      end
+
+      it 'normalizes phone numbers' do
+        expect(matches?(leaf('phone_number', 'equal_to', contact.phone_number.delete('+')))).to be(true)
+      end
+
+      it 'supports presence checks' do
+        expect(matches?(leaf('email', 'is_present'))).to be(true)
+        expect(matches?(leaf('identifier', 'is_not_present'))).to be(true)
+      end
+
+      it 'matches blocked boolean' do
+        contact.update!(blocked: true)
+        expect(matches?(leaf('blocked', 'equal_to', 'true'))).to be(true)
+      end
+
+      it 'supports days_before on created_at' do
+        contact.update!(created_at: 40.days.ago)
+        expect(matches?(leaf('created_at', 'days_before', '30'))).to be(true)
+        expect(matches?(leaf('created_at', 'days_before', '60'))).to be(false)
+      end
+
+      it 'compares date custom attributes stored as ISO strings' do
+        contact.update!(custom_attributes: contact.custom_attributes.merge('signed_up_on' => '2024-01-15'))
+        expect(matches?(leaf('signed_up_on', 'is_greater_than', '2024-01-01'))).to be(true)
+        expect(matches?(leaf('signed_up_on', 'is_less_than', '2024-01-01'))).to be(false)
+        expect(matches?(leaf('signed_up_on', 'is_less_than', '2024-02-01'))).to be(true)
+      end
+    end
+
+    context 'with labels' do
+      before { contact.update_labels(%w[vip]) }
+
+      it 'matches has-tag semantics' do
+        expect(matches?(leaf('labels', 'equal_to', 'vip'))).to be(true)
+        expect(matches?(leaf('labels', 'equal_to', 'enterprise'))).to be(false)
+      end
+
+      it 'matches any of multiple selected labels' do
+        expect(matches?(leaf('labels', 'equal_to', %w[enterprise vip]))).to be(true)
+        expect(matches?(leaf('labels', 'equal_to', %w[enterprise smb]))).to be(false)
+      end
+
+      it 'not_equal_to rejects contacts carrying any selected label' do
+        expect(matches?(leaf('labels', 'not_equal_to', %w[enterprise vip]))).to be(false)
+        expect(matches?(leaf('labels', 'not_equal_to', %w[enterprise smb]))).to be(true)
+      end
+    end
+
+    context 'with browser language' do
+      it 'resolves browser_language from the conversation' do
+        expect(matches?(leaf('browser_language', 'equal_to', 'en'))).to be(true)
+      end
+    end
+
+    context 'with the logged-in (hmac_verified) flag' do
+      it 'matches a verified contact inbox' do
+        conversation.contact_inbox.update!(hmac_verified: true)
+        expect(matches?(leaf('hmac_verified', 'equal_to', 'true'))).to be(true)
+        expect(matches?(leaf('hmac_verified', 'equal_to', 'false'))).to be(false)
+      end
+
+      it 'treats an unverified contact inbox as not logged in' do
+        conversation.contact_inbox.update!(hmac_verified: false)
+        expect(matches?(leaf('hmac_verified', 'equal_to', 'false'))).to be(true)
+        expect(matches?(leaf('hmac_verified', 'equal_to', 'true'))).to be(false)
+      end
+    end
+
+    context 'with nested groups' do
+      let(:audience) do
+        {
+          'operator' => 'and',
+          'conditions' => [
+            leaf('country_code', 'equal_to', 'US'),
+            {
+              'operator' => 'or',
+              'conditions' => [
+                leaf('created_at', 'days_before', '3650'),
+                leaf('plan_tier', 'equal_to', 'paid')
+              ]
+            }
+          ]
+        }
+      end
+
+      it 'evaluates OR inside AND with correct precedence' do
+        expect(matches?(audience)).to be(true)
+      end
+
+      it 'fails the AND when the top-level condition is false' do
+        audience['conditions'][0] = leaf('country_code', 'equal_to', 'CA')
+        expect(matches?(audience)).to be(false)
+      end
+
+      it 'fails when neither OR branch matches' do
+        audience['conditions'][1]['conditions'] = [
+          leaf('created_at', 'days_before', '3650'),
+          leaf('plan_tier', 'equal_to', 'free')
+        ]
+        expect(matches?(audience)).to be(false)
+      end
+    end
+  end
+end
diff --git a/spec/enterprise/services/enterprise/message_templates/hook_execution_service_spec.rb b/spec/enterprise/services/enterprise/message_templates/hook_execution_service_spec.rb
index bacb403ec..f4974c1b5 100644
--- a/spec/enterprise/services/enterprise/message_templates/hook_execution_service_spec.rb
+++ b/spec/enterprise/services/enterprise/message_templates/hook_execution_service_spec.rb
@@ -224,6 +224,92 @@ RSpec.describe MessageTemplates::HookExecutionService do
     end
   end
 
+  context 'when the contact is inside the assistant audience' do
+    before do
+      assistant.update!(config: assistant.config.merge('audience' => {
+                                                         'attribute_key' => 'country_code', 'filter_operator' => 'equal_to', 'values' => ['US']
+                                                       }))
+      contact.update!(additional_attributes: { 'country_code' => 'US' })
+    end
+
+    it 'schedules captain response job' do
+      expect(Captain::Conversation::ResponseBuilderJob).to receive(:perform_later).with(conversation, assistant)
+
+      create(:message, conversation: conversation, message_type: :incoming, account: account)
+    end
+  end
+
+  context 'when the conversation stops matching the audience mid-conversation' do
+    it 'still schedules captain response job for the pending conversation' do
+      conversation
+      assistant.update!(config: assistant.config.merge('audience' => {
+                                                         'attribute_key' => 'country_code', 'filter_operator' => 'equal_to', 'values' => ['US']
+                                                       }))
+      contact.update!(additional_attributes: { 'country_code' => 'CA' })
+
+      expect(Captain::Conversation::ResponseBuilderJob).to receive(:perform_later).with(conversation, assistant)
+
+      create(:message, conversation: conversation, message_type: :incoming, account: account)
+    end
+  end
+
+  context 'when the reply schedule stops matching mid-conversation' do
+    before do
+      inbox.update!(working_hours_enabled: true)
+      inbox.working_hours.find_by(day_of_week: Time.current.in_time_zone(inbox.timezone).wday).update!(
+        open_all_day: true,
+        closed_all_day: false
+      )
+    end
+
+    it 'still schedules captain response job when business hours end after captain took the conversation' do
+      assistant.update!(config: assistant.config.merge('response_window' => 'business_hours'))
+      conversation
+      inbox.working_hours.find_by(day_of_week: Time.current.in_time_zone(inbox.timezone).wday).update!(
+        open_all_day: false,
+        closed_all_day: true
+      )
+
+      expect(Captain::Conversation::ResponseBuilderJob).to receive(:perform_later).with(conversation, assistant)
+
+      create(:message, conversation: conversation, message_type: :incoming, account: account)
+    end
+
+    it 'still schedules captain response job when business hours begin after captain took the conversation' do
+      assistant.update!(config: assistant.config.merge('response_window' => 'outside_business_hours'))
+      inbox.working_hours.find_by(day_of_week: Time.current.in_time_zone(inbox.timezone).wday).update!(
+        open_all_day: false,
+        closed_all_day: true
+      )
+      conversation
+      inbox.working_hours.find_by(day_of_week: Time.current.in_time_zone(inbox.timezone).wday).update!(
+        open_all_day: true,
+        closed_all_day: false
+      )
+
+      expect(Captain::Conversation::ResponseBuilderJob).to receive(:perform_later).with(conversation, assistant)
+
+      create(:message, conversation: conversation, message_type: :incoming, account: account)
+    end
+
+    it 'still schedules captain response job when both audience and schedule stop matching' do
+      assistant.update!(config: assistant.config.merge('response_window' => 'business_hours'))
+      conversation
+      assistant.update!(config: assistant.config.merge('audience' => {
+                                                         'attribute_key' => 'country_code', 'filter_operator' => 'equal_to', 'values' => ['US']
+                                                       }))
+      contact.update!(additional_attributes: { 'country_code' => 'CA' })
+      inbox.working_hours.find_by(day_of_week: Time.current.in_time_zone(inbox.timezone).wday).update!(
+        open_all_day: false,
+        closed_all_day: true
+      )
+
+      expect(Captain::Conversation::ResponseBuilderJob).to receive(:perform_later).with(conversation, assistant)
+
+      create(:message, conversation: conversation, message_type: :incoming, account: account)
+    end
+  end
+
   context 'when message is outgoing' do
     it 'does not schedule captain response job' do
       expect(Captain::Conversation::ResponseBuilderJob).not_to receive(:perform_later)