feat(ai): per-channel response mode (off / mention-only / vibe)

[BillChirico]

Overview

Allow server admins to control how the AI bot responds in each channel. Three modes, configurable per channel from the dashboard.

Response Modes

Mode	Behavior
Off	Bot never responds in this channel
Mention only	Bot only responds when directly @mentioned (default for all channels)
Vibe	Bot responds whenever it judges the conversation warrants a reply

Default: All channels start in mention mode. Admins opt individual channels into vibe or off.

Config Schema

{
  "ai": {
    "channelModes": {
      "123456789": "off",
      "987654321": "vibe"
    },
    "defaultChannelMode": "mention"
  }
}

Channels absent from channelModes inherit defaultChannelMode. This keeps the config small — only overrides need to be stored.

Backend Changes

• src/modules/ai.js — before handling any message, resolve the effective mode:

  const mode = config.ai.channelModes?.[channel.id] ?? config.ai.defaultChannelMode ?? 'mention';
  if (mode === 'off') return;
  if (mode === 'mention' && !message.mentions.has(client.user)) return;
  // mode === 'vibe' — fall through to AI judgment

• Existing blockedChannelIds still applies (hard block, no response at all)
• src/api/routes/config.js — channelModes must be in SAFE_CONFIG_KEYS

Dashboard UI/UX

Channel Mode List (primary UI)

• Lives in the AI config section, below the existing AI toggles
• Shows all channels in the server (fetched from Discord API)
• Grouped by category (mirrors Discord's channel list layout)
• Each channel row has:
  • Channel icon + name
  • A 3-option segmented control (pill selector): Off · Mention · Vibe
  • Active mode highlighted; default (mention) shown with a subtle "default" badge so it's clear nothing is explicitly set
• Channels with non-default settings bubble to the top or get a visual indicator (e.g. colored dot)
• Search/filter bar to find a channel quickly
• "Reset all to default" button

Mode Selector Component

┌─────────────────────────────────────────────┐
│ # general                                    │
│              [ Off ] [ Mention ✓] [ Vibe ]  │
├─────────────────────────────────────────────┤
│ # announcements                              │
│              [ Off ✓] [ Mention ] [ Vibe ]  │
├─────────────────────────────────────────────┤
│ # random                                     │
│              [ Off ] [ Mention ] [ Vibe ✓]  │
└─────────────────────────────────────────────┘

• Segmented control (not a dropdown) — all 3 options visible at a glance, one tap to switch
• Mobile-first: control stacks below the channel name on narrow screens
• Saving: changes are staged and saved with the rest of the config (no per-row auto-save)
• Empty state: "No channels found" when search returns nothing

Global Default Setting

Above the channel list, a single prominent selector sets the server-wide default:

Default mode for all channels
[ Off ] [ Mention (recommended) ✓] [ Vibe ]

Changing this updates all channels that haven't been explicitly overridden.

Acceptance Criteria

• ai.defaultChannelMode config field, defaults to 'mention'
• ai.channelModes map, starts empty (channels inherit default)
• Bot respects mode before processing any AI message
• vibe mode still uses existing AI judgment logic (no additional prompting needed)
• Dashboard shows all channels grouped by category
• Segmented 3-option control per channel, mobile-responsive
• Global default selector at the top of the section
• Non-default channels visually distinguished
• Search to filter channels
• "Reset to default" per channel and globally
• channelModes in SAFE_CONFIG_KEYS
• Unit tests for mode resolution logic
• Existing blockedChannelIds behavior unchanged

[coderabbitai]

Coding Plan

Summary

• Mode resolution happens early in message handling, after blocklist check but before triggered/passive path split
• mention mode preserves current default behavior (respond only on @mention), while vibe enables the existing passive triage path
• Dashboard fetches channels with category info to render a grouped list with inline segmented controls
• Only explicit overrides are stored in config; channels inherit the global default, keeping storage minimal

Design Choices

Design Choice 1: Thread channel mode inheritance

Options Considered:

1. Check thread's own channel ID in channelModes, fall back to parent if not found
2. Always use parent channel ID for threads (consistent with blocklist behavior)

Chosen Option: 2

Rationale: Always resolve mode from parent channel for threads, matching existing isChannelBlocked() pattern and avoiding config fragmentation.

Design Choice 2: Segmented control implementation

Options Considered:

1. Install shadcn's toggle-group component (adds @radix-ui/react-toggle-group dependency)
2. Build a lightweight custom component using existing Button styling with group semantics

Chosen Option: 2

Rationale: Build a custom ModeSelector component using button primitives — keeps dependencies minimal and matches the pattern of other custom UI components (ChannelSelector, RoleSelector).

💡 User Tips

Regenerate the plan with different choices with @coderabbitai <feedback>.

Implementation Steps

Phase 1: Backend Mode Resolution and Message Routing

Add the configuration schema, mode resolution utility, and integrate mode-based gating into the message handling flow. This phase delivers the complete backend functionality.

Task 1: Task 1.1: Add Configuration Schema and Validation

Extend the AI config schema to include the new mode fields and ensure they pass API validation.

• Update config.json to add ai.channelModes: {} (empty object) and ai.defaultChannelMode: "mention" as defaults
• Add schema validation in src/api/utils/configValidation.js under the ai schema entry: channelModes as type: 'object' with openProperties: true, and defaultChannelMode as type: 'string'
• Verify ai is already in SAFE_CONFIG_KEYS in src/api/utils/configAllowlist.js (it is — no change needed since channelModes is nested under ai)

Task 2: Task 1.2: Create Mode Resolution Utility

Add a utility function to resolve the effective mode for any channel, handling threads and defaults.

• Create getChannelMode(channelId, parentId, guildId) in src/modules/ai.js adjacent to existing isChannelBlocked()
• Resolution order: check channelModes[channelId] first, then channelModes[parentId] if in a thread, then defaultChannelMode, then hardcoded 'mention' fallback
• Return one of 'off', 'mention', or 'vibe'
• Export the function for use in message handlers

Task 3: Task 1.3: Integrate Mode Gating into Message Handler

Modify the message routing logic to respect channel modes, preserving existing blocklist behavior.

• In src/modules/events/messageCreate.js, after the existing isChannelBlocked() check (~line 180), add mode resolution
• For off mode: early return (similar to blocklist)
• For mention mode: allow the triggered path (mention/reply) but skip the passive fire-and-forget accumulateMessage at the bottom
• For vibe mode: allow both triggered path (if mentioned) and passive path (existing behavior)
• The key change is gating the passive path (~line 259) with mode === 'vibe' instead of just ai.enabled

Task 4: Task 1.4: Unit Tests for Mode Resolution

Add comprehensive tests covering mode resolution and message routing behavior.

• Add tests in tests/modules/ai.test.js for getChannelMode(): default fallback, explicit channel override, thread inheritance from parent, missing config handling
• Add tests in tests/modules/events.test.js for message routing: off mode blocks both paths, mention mode blocks passive path, vibe mode allows passive path, mode doesn't override blocklist

🤖 Prompt for AI agents

Implement the full backend for per-channel AI response modes, covering config
schema, mode resolution logic, message handler gating, and unit tests.

**Task 1.1 – Config Schema and Validation:**
- In `config.json`, add `ai.channelModes: {}` (empty object default) and
`ai.defaultChannelMode: "mention"` under the `ai` section
- In `src/api/utils/configValidation.js`, under the `ai` schema entry, add:
  - `channelModes`: `type: 'object'`, `openProperties: true`
  - `defaultChannelMode`: `type: 'string'`
- In `src/api/utils/configAllowlist.js`, verify `ai` is already listed in
`SAFE_CONFIG_KEYS` — no changes needed since new fields are nested under `ai`

**Task 1.2 – Mode Resolution Utility:**
- In `src/modules/ai.js`, add and export a new function
`getChannelMode(channelId, parentId, guildId)` placed adjacent to the existing
`isChannelBlocked()` function
- Resolution order (first match wins):
  1. `channelModes[channelId]`
2. `channelModes[parentId]` (only if `parentId` is present — i.e., the channel
is a thread)
  3. `defaultChannelMode` from config
  4. Hardcoded fallback: `'mention'`
- Return value must be one of: `'off'`, `'mention'`, `'vibe'`

**Task 1.3 – Message Handler Mode Gating:**
- In `src/modules/events/messageCreate.js`, after the existing
`isChannelBlocked()` check (~line 180), call `getChannelMode()` to resolve the
current channel's mode
- Apply gating logic:
  - `off`: early return (same pattern as blocklist rejection)
- `mention`: allow the triggered path (mention/reply) but do NOT call
`accumulateMessage` at the bottom of the handler
  - `vibe`: allow both triggered and passive paths (existing behavior)
- Gate the passive path call (~line 259) with `mode === 'vibe'` instead of just
checking `ai.enabled`

**Task 1.4 – Unit Tests:**
- In `tests/modules/ai.test.js`, add tests for `getChannelMode()`:
  - Returns `'mention'` when no config is present (default fallback)
  - Returns explicit override when `channelModes[channelId]` is set
  - Inherits from `channelModes[parentId]` when called from a thread
  - Handles missing/undefined config gracefully
- In `tests/modules/events.test.js`, add tests for message routing:
  - `off` mode blocks both triggered and passive paths
  - `mention` mode blocks the passive path but allows triggered path
  - `vibe` mode allows both paths
  - Mode gating does not interfere with or override the existing blocklist check

Phase 2: Dashboard Channel Mode UI

Build the dashboard interface for configuring channel modes, including the global default selector, grouped channel list, and per-channel segmented controls.

Task 1: Task 2.1: Extend TypeScript Types

Update type definitions to include the new config fields.

• In web/src/types/config.ts, extend AiConfig interface to add channelModes: Record<string, 'off' | 'mention' | 'vibe'> and defaultChannelMode: 'off' | 'mention' | 'vibe'
• Add a ChannelMode type alias for the union 'off' | 'mention' | 'vibe'

Task 2: Task 2.2: Enhance Channel API with Parent Information

Add parentId to channel responses so the dashboard can group channels by category.

• In src/api/routes/guilds.js, modify getGuildChannels() to include parentId: ch.parentId ?? null and position: ch.position in each channel object
• This enables proper category-based grouping in the UI

Task 3: Task 2.3: Create Mode Selector Component

Build a reusable segmented control component for the 3-way mode selection.

• Create web/src/components/ui/mode-selector.tsx as a new component
• Props: value: ChannelMode, onChange: (mode: ChannelMode) => void, disabled?: boolean, showDefaultBadge?: boolean
• Render three adjacent buttons styled as a pill group (rounded ends on first/last, flat joins in middle)
• Active state uses primary background; inactive uses ghost/secondary styling
• When showDefaultBadge is true and value equals the passed default, show a subtle "default" badge

Task 4: Task 2.4: Create Channel Mode List Component

Build the main channel mode configuration UI as a new section component.

• Create web/src/components/dashboard/config-sections/ChannelModeSection.tsx
• Props: guildId, channelModes, defaultMode, onChannelModeChange, onDefaultModeChange, onResetAll, disabled
• Fetch channels from /api/guilds/{guildId}/channels on mount (similar to ChannelSelector)
• Global default selector at top: ModeSelector bound to defaultChannelMode
• Search bar: filter channels by name using Input component
• Channel list: group channels by parentId (category), show category headers, render each channel with icon + name + ModeSelector
• Channels with explicit overrides (different from default) show a visual indicator (colored dot or highlight)
• Non-default channels optionally sorted to top within their category
• Reset buttons: "Reset to default" per-row (removes from channelModes), "Reset all" button clears the entire map
• Empty state when search yields no results

Task 5: Task 2.5: Integrate into Config Editor

Wire the new component into the existing AI config section.

• In web/src/components/dashboard/config-editor.tsx, add draft state updaters for channelModes and defaultChannelMode
• Add updateChannelMode(channelId, mode): if mode equals default, remove from map; otherwise set in map
• Add updateDefaultChannelMode(mode): sets the default
• Add resetAllChannelModes(): clears the channelModes object
• Render ChannelModeSection within the AI automation category, below the existing AI Chat feature card
• Pass through all required props connecting draft state to the component

🤖 Prompt for AI agents

Build the full dashboard UI for per-channel AI response mode configuration,
spanning TypeScript types, API enhancements, new components, and config editor
integration.

**Task 2.1 – TypeScript Types (`web/src/types/config.ts`):**
- Add a `ChannelMode` type alias: `'off' | 'mention' | 'vibe'`
- Extend the `AiConfig` interface with:
  - `channelModes: Record<string, ChannelMode>`
  - `defaultChannelMode: ChannelMode`

**Task 2.2 – Channel API Enhancement (`src/api/routes/guilds.js`):**
- In `getGuildChannels()`, include `parentId: ch.parentId ?? null` and
`position: ch.position` in each returned channel object
- This data enables category-based grouping on the frontend

**Task 2.3 – `ModeSelector` Component
(`web/src/components/ui/mode-selector.tsx`):**
- Create a new component with props: `value: ChannelMode`, `onChange: (mode:
ChannelMode) => void`, `disabled?: boolean`, `showDefaultBadge?: boolean`
- Render three adjacent buttons (for `off`, `mention`, `vibe`) styled as a pill
group:
- First button: rounded left end; last button: rounded right end; middle button:
flat joins
  - Active state: primary background styling
  - Inactive state: ghost/secondary styling
- When `showDefaultBadge` is true and the current value matches the passed
default, display a subtle "default" badge
- Use existing `Button` primitives for styling — do not add new dependencies

**Task 2.4 – `ChannelModeSection` Component
(`web/src/components/dashboard/config-sections/ChannelModeSection.tsx`):**
- Props: `guildId`, `channelModes`, `defaultMode`, `onChannelModeChange`,
`onDefaultModeChange`, `onResetAll`, `disabled`
- On mount, fetch channels from `/api/guilds/{guildId}/channels` (mirror
`ChannelSelector` fetch pattern)
- Render:
- **Global default selector**: `ModeSelector` bound to `defaultChannelMode` at
the top
  - **Search bar**: `Input` component to filter channels by name
- **Channel list**: grouped by `parentId` (category), with category headers;
each channel row shows icon + name + `ModeSelector`
- Channels with explicit overrides (value differs from default) show a visual
indicator (colored dot or highlight)
  - Non-default channels optionally sorted to top within their category
- **Per-row reset button**: "Reset to default" — removes the channel from
`channelModes`
- **"Reset all" button**: clears the entire `channelModes` map via `onResetAll`
  - Empty state message when search yields no results

**Task 2.5 – Config Editor Integration
(`web/src/components/dashboard/config-editor.tsx`):**
- Add draft state updater functions:
- `updateChannelMode(channelId, mode)`: if `mode` equals the current default,
remove `channelId` from the map; otherwise set it
  - `updateDefaultChannelMode(mode)`: sets `defaultChannelMode` in draft state
  - `resetAllChannelModes()`: clears the `channelModes` object in draft state
- Render `ChannelModeSection` inside the AI automation category section, below
the existing AI Chat feature card
- Pass all required props from draft state and updater functions to
`ChannelModeSection`

Research

The bot uses a two-path AI response system: a "triggered" path (immediate response on @mention/reply) and a "passive" path (buffered messages evaluated periodically by triage). Message routing lives in src/modules/events/messageCreate.js, with src/modules/ai.js providing utilities like isChannelBlocked(). Config is stored per-guild in PostgreSQL, validated via schemas in src/api/utils/configValidation.js, and exposed through SAFE_CONFIG_KEYS. The dashboard is a Next.js app that proxies to the bot API, with config editing centralized in config-editor.tsx using draft state and sectioned feature cards.

---

🚀 Next Steps

🤖 All AI agent prompts combined

Task: 1

Implement the full backend for per-channel AI response modes, covering config
schema, mode resolution logic, message handler gating, and unit tests.

**Task 1.1 – Config Schema and Validation:**
- In `config.json`, add `ai.channelModes: {}` (empty object default) and
`ai.defaultChannelMode: "mention"` under the `ai` section
- In `src/api/utils/configValidation.js`, under the `ai` schema entry, add:
  - `channelModes`: `type: 'object'`, `openProperties: true`
  - `defaultChannelMode`: `type: 'string'`
- In `src/api/utils/configAllowlist.js`, verify `ai` is already listed in
`SAFE_CONFIG_KEYS` — no changes needed since new fields are nested under `ai`

**Task 1.2 – Mode Resolution Utility:**
- In `src/modules/ai.js`, add and export a new function
`getChannelMode(channelId, parentId, guildId)` placed adjacent to the existing
`isChannelBlocked()` function
- Resolution order (first match wins):
  1. `channelModes[channelId]`
2. `channelModes[parentId]` (only if `parentId` is present — i.e., the channel
is a thread)
  3. `defaultChannelMode` from config
  4. Hardcoded fallback: `'mention'`
- Return value must be one of: `'off'`, `'mention'`, `'vibe'`

**Task 1.3 – Message Handler Mode Gating:**
- In `src/modules/events/messageCreate.js`, after the existing
`isChannelBlocked()` check (~line 180), call `getChannelMode()` to resolve the
current channel's mode
- Apply gating logic:
  - `off`: early return (same pattern as blocklist rejection)
- `mention`: allow the triggered path (mention/reply) but do NOT call
`accumulateMessage` at the bottom of the handler
  - `vibe`: allow both triggered and passive paths (existing behavior)
- Gate the passive path call (~line 259) with `mode === 'vibe'` instead of just
checking `ai.enabled`

**Task 1.4 – Unit Tests:**
- In `tests/modules/ai.test.js`, add tests for `getChannelMode()`:
  - Returns `'mention'` when no config is present (default fallback)
  - Returns explicit override when `channelModes[channelId]` is set
  - Inherits from `channelModes[parentId]` when called from a thread
  - Handles missing/undefined config gracefully
- In `tests/modules/events.test.js`, add tests for message routing:
  - `off` mode blocks both triggered and passive paths
  - `mention` mode blocks the passive path but allows triggered path
  - `vibe` mode allows both paths
  - Mode gating does not interfere with or override the existing blocklist check
===============================================================================

Task: 2

Build the full dashboard UI for per-channel AI response mode configuration,
spanning TypeScript types, API enhancements, new components, and config editor
integration.

**Task 2.1 – TypeScript Types (`web/src/types/config.ts`):**
- Add a `ChannelMode` type alias: `'off' | 'mention' | 'vibe'`
- Extend the `AiConfig` interface with:
  - `channelModes: Record<string, ChannelMode>`
  - `defaultChannelMode: ChannelMode`

**Task 2.2 – Channel API Enhancement (`src/api/routes/guilds.js`):**
- In `getGuildChannels()`, include `parentId: ch.parentId ?? null` and
`position: ch.position` in each returned channel object
- This data enables category-based grouping on the frontend

**Task 2.3 – `ModeSelector` Component
(`web/src/components/ui/mode-selector.tsx`):**
- Create a new component with props: `value: ChannelMode`, `onChange: (mode:
ChannelMode) => void`, `disabled?: boolean`, `showDefaultBadge?: boolean`
- Render three adjacent buttons (for `off`, `mention`, `vibe`) styled as a pill
group:
- First button: rounded left end; last button: rounded right end; middle button:
flat joins
  - Active state: primary background styling
  - Inactive state: ghost/secondary styling
- When `showDefaultBadge` is true and the current value matches the passed
default, display a subtle "default" badge
- Use existing `Button` primitives for styling — do not add new dependencies

**Task 2.4 – `ChannelModeSection` Component
(`web/src/components/dashboard/config-sections/ChannelModeSection.tsx`):**
- Props: `guildId`, `channelModes`, `defaultMode`, `onChannelModeChange`,
`onDefaultModeChange`, `onResetAll`, `disabled`
- On mount, fetch channels from `/api/guilds/{guildId}/channels` (mirror
`ChannelSelector` fetch pattern)
- Render:
- **Global default selector**: `ModeSelector` bound to `defaultChannelMode` at
the top
  - **Search bar**: `Input` component to filter channels by name
- **Channel list**: grouped by `parentId` (category), with category headers;
each channel row shows icon + name + `ModeSelector`
- Channels with explicit overrides (value differs from default) show a visual
indicator (colored dot or highlight)
  - Non-default channels optionally sorted to top within their category
- **Per-row reset button**: "Reset to default" — removes the channel from
`channelModes`
- **"Reset all" button**: clears the entire `channelModes` map via `onResetAll`
  - Empty state message when search yields no results

**Task 2.5 – Config Editor Integration
(`web/src/components/dashboard/config-editor.tsx`):**
- Add draft state updater functions:
- `updateChannelMode(channelId, mode)`: if `mode` equals the current default,
remove `channelId` from the map; otherwise set it
  - `updateDefaultChannelMode(mode)`: sets `defaultChannelMode` in draft state
  - `resetAllChannelModes()`: clears the `channelModes` object in draft state
- Render `ChannelModeSection` inside the AI automation category section, below
the existing AI Chat feature card
- Pass all required props from draft state and updater functions to
`ChannelModeSection`

💡 Iterate on the plan with: @coderabbitai <feedback>

Example Feedback
- `@coderabbitai` You can skip phase 3. Add a simple unit test case for phase 2.
- `@coderabbitai` For design choice 1 go ahead with option 3 and replan.

---

💬 Have feedback or questions? Drop into our discord!

[coderabbitai]

🔗 Related PRs

#12 - feat: add chime-in — bot organically joins conversations [merged]
#192 - fix: AI channel blocklist - rebase on main [merged]
#225 - feat(ai): add blocked channel check to triage module (#180) [merged]
#256 - feat(ai): configurable channel blocklist dashboard UI [merged]
#258 - feat(dashboard): config diff enhancements — unsaved indicator, Ctrl+S, undo, per-section revert [merged]

---

📝 Issue Planner

_{Check the box below or use the @coderabbitai plan command to generate an implementation plan and prompts that you can use with your favorite coding assistant.}

• Create Plan

---

🧪 Issue enrichment is currently in open beta.

To disable automatic issue enrichment, add the following to your .coderabbit.yaml:

issue_enrichment:
  auto_enrich:
    enabled: false

💬 Have feedback or questions? Drop into our discord!