@hybridaione/hybridclaw 0.2.2 → 0.2.3

package/CHANGELOG.md

@@ -8,6 +8,21 @@
 
 ### Fixed
 
+## [0.2.3](https://github.com/HybridAIOne/hybridclaw/tree/v0.2.3)
+
+### Added
+
+- **Discord channel policy config**: Added typed runtime config support for `discord.groupPolicy` (`open`/`allowlist`/`disabled`), `discord.freeResponseChannels`, and per-guild/per-channel mode overrides at `discord.guilds.<guildId>.channels.<channelId>.mode`.
+- **Discord channel mode slash command**: Added `/channel-mode` with `off`, `mention`, and `free` options to set the active guild channel behavior directly from Discord.
+- **Gateway channel control commands**: Added `channel mode` and `channel policy` command flows for inspecting/updating Discord channel response behavior via `!claw` commands.
+
+### Changed
+
+- **Discord trigger enforcement**: Guild message handling now applies channel mode + group policy before normal trigger checks, while still allowing prefixed commands in disabled channels.
+- **Activation/status labeling**: Runtime status output now reflects `disabled`/`allowlist`/mixed free-channel activation modes instead of only legacy mention/all-messages labels.
+
+### Fixed
+
 ## [0.2.2](https://github.com/HybridAIOne/hybridclaw/tree/v0.2.2)
 
 ### Added

package/README.md

@@ -11,17 +11,15 @@ npm install -g @hybridaione/hybridclaw
 hybridclaw onboarding
 ```
 
-Latest release: [v0.2.2](https://github.com/HybridAIOne/hybridclaw/releases/tag/v0.2.2)
+Latest release: [v0.2.3](https://github.com/HybridAIOne/hybridclaw/releases/tag/v0.2.3)
 
-## What's new in v0.2.2
+## What's new in v0.2.3
 
-- Added Discord attachment ingest/cache with structured media context (`path`, `mime`, `size`, `original_url`) passed into the agent pipeline
-- Added `vision_analyze`/`image` tools for Discord-uploaded image analysis (local cached path first, Discord CDN fallback)
-- Added native model vision image-part injection for vision-capable models, with safe fallback if multimodal input is rejected
-- Routed Discord image questions away from `browser_vision` (unless explicitly about the active browser tab/page)
-- Completed Discord runtime migration into `src/channels/discord/*` and removed the legacy root-level `src/discord.ts` shim
-- Switched tests from compiled `dist-tests` artifacts to direct TypeScript execution via Vitest
-- Moved basic tests to `tests/` with explicit scope naming conventions
+- Added Discord guild channel policy controls with typed config: `discord.groupPolicy`, `discord.freeResponseChannels`, and `discord.guilds.<guildId>.channels.<channelId>.mode`
+- Added `/channel-mode` slash command to switch a channel between `off`, `mention`, and `free`
+- Added `!claw channel mode` and `!claw channel policy` command flows for in-chat policy changes
+- Enforced channel mode/policy in Discord trigger logic while keeping prefixed commands available
+- Updated status/activation labeling to reflect allowlist/disabled/mixed channel policy modes
 
 ## HybridAI Advantage
 
@@ -108,6 +106,10 @@ HybridClaw uses typed runtime config in `config.json` (auto-created on first run
 - `discord.respondToAllMessages` changes guild trigger behavior: `false` (default) replies only on mention/`!claw`; `true` replies to every user message in the channel
 - `discord.commandUserId` restricts `!claw <command>` admin commands to a single Discord user ID (all other messages still use normal chat handling)
 - `discord.commandsOnly` optional hard mode: if `true`, the bot ignores non-`!claw` messages and only accepts prefixed commands (optionally limited by `discord.commandUserId`)
+- `discord.groupPolicy` controls guild channel scope: `open` (default), `allowlist`, or `disabled`
+- `discord.freeResponseChannels` is a Hermes-style channel ID list that gets free-response behavior while other channels remain mention-gated
+- `discord.guilds.<guildId>.channels.<channelId>.mode` sets per-channel behavior to `off`, `mention`, or `free` (works with `allowlist` policy)
+- Discord slash commands: `/status` and `/channel-mode <off|mention|free>` (ephemeral replies)
 - `skills.extraDirs` adds additional enterprise/shared skill roots (lowest precedence tier)
 - `proactive.*` controls autonomous behavior (`activeHours`, `delegation`, `autoRetry`, `ralph`)
 - `proactive.ralph.maxIterations` enables Ralph loop (`0` off, `-1` unlimited, `>0` extra autonomous iterations before forcing completion)

package/config.example.json

@@ -15,7 +15,10 @@
     "presenceIntent": false,
     "respondToAllMessages": false,
     "commandsOnly": false,
-    "commandUserId": ""
+    "commandUserId": "",
+    "groupPolicy": "open",
+    "freeResponseChannels": [],
+    "guilds": {}
   },
   "hybridai": {
     "baseUrl": "https://hybridai.one",

package/container/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "hybridclaw-agent",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "hybridclaw-agent",
-      "version": "0.2.2",
+      "version": "0.2.3",
       "dependencies": {
         "@mozilla/readability": "^0.6.0",
         "agent-browser": "^0.15.1",

package/container/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hybridclaw-agent",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "type": "module",
   "scripts": {
     "build": "tsc",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hybridaione/hybridclaw",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "type": "module",
   "description": "Personal AI assistant bot for Discord, powered by HybridAI",
   "publishConfig": {

package/src/channels/discord/inbound.ts

@@ -4,6 +4,8 @@ export interface ParsedCommand {
   args: string[];
 }
 
+export type DiscordGuildMessageMode = 'off' | 'mention' | 'free';
+
 export function stripBotMentions(text: string, botMentionRegex: RegExp | null): string {
   if (!botMentionRegex) return text;
   return text.replace(botMentionRegex, '').trim();
@@ -45,7 +47,7 @@ export function parseCommand(
   }
 
   const parts = text.split(/\s+/);
-  const subcommands = ['bot', 'rag', 'model', 'sessions', 'audit', 'schedule', 'clear', 'help'];
+  const subcommands = ['bot', 'rag', 'model', 'sessions', 'audit', 'schedule', 'channel', 'clear', 'help'];
   if (parts.length > 0 && subcommands.includes(parts[0].toLowerCase())) {
     return { isCommand: true, command: parts[0].toLowerCase(), args: parts.slice(1) };
   }
@@ -58,6 +60,7 @@ export function isTrigger(params: {
   isDm: boolean;
   commandsOnly: boolean;
   respondToAllMessages: boolean;
+  guildMessageMode: DiscordGuildMessageMode;
   prefix: string;
   botMentionRegex: RegExp | null;
   hasBotMention: boolean;
@@ -66,7 +69,10 @@ export function isTrigger(params: {
     return hasPrefixInvocation(params.content, params.botMentionRegex, params.prefix);
   }
   if (params.isDm) return true;
+  if (hasPrefixInvocation(params.content, params.botMentionRegex, params.prefix)) return true;
+  if (params.guildMessageMode === 'off') return false;
+  if (params.guildMessageMode === 'free') return true;
   if (params.respondToAllMessages) return true;
   if (params.hasBotMention) return true;
-  return params.content.startsWith(params.prefix);
+  return false;
 }

package/src/channels/discord/runtime.ts

@@ -1,8 +1,10 @@
 import {
   ActivityType,
+  ApplicationCommandOptionType,
   AttachmentBuilder,
   Client,
   GatewayIntentBits,
+  type ApplicationCommandDataResolvable,
   type Message as DiscordMessage,
   Partials,
 } from 'discord.js';
@@ -10,7 +12,10 @@ import {
 import {
   DISCORD_COMMAND_USER_ID,
   DISCORD_COMMANDS_ONLY,
+  DISCORD_FREE_RESPONSE_CHANNELS,
+  DISCORD_GROUP_POLICY,
   DISCORD_GUILD_MEMBERS_INTENT,
+  DISCORD_GUILDS,
   DISCORD_PRESENCE_INTENT,
   DISCORD_PREFIX,
   DISCORD_RESPOND_TO_ALL_MESSAGES,
@@ -23,6 +28,7 @@ import {
   hasPrefixInvocation as hasPrefixInvocationInbound,
   isTrigger as isTriggerInbound,
   parseCommand as parseCommandInbound,
+  type DiscordGuildMessageMode,
   type ParsedCommand,
 } from './inbound.js';
 import {
@@ -433,12 +439,29 @@ function buildSessionIdFromContext(guildId: string | null, channelId: string, us
   return buildSessionIdFromContextInbound(guildId, channelId, userId);
 }
 
+function resolveGuildMessageMode(msg: DiscordMessage): DiscordGuildMessageMode {
+  if (!msg.guild) return 'free';
+  if (DISCORD_GROUP_POLICY === 'disabled') return 'off';
+
+  const guildConfig = DISCORD_GUILDS[msg.guild.id];
+  const explicitMode = guildConfig?.channels[msg.channelId]?.mode;
+  if (DISCORD_GROUP_POLICY === 'allowlist') {
+    return explicitMode ?? 'off';
+  }
+  if (explicitMode) return explicitMode;
+  if (DISCORD_FREE_RESPONSE_CHANNELS.includes(msg.channelId)) return 'free';
+  if (guildConfig) return guildConfig.defaultMode;
+  if (DISCORD_RESPOND_TO_ALL_MESSAGES) return 'free';
+  return 'mention';
+}
+
 function isTrigger(msg: DiscordMessage): boolean {
   return isTriggerInbound({
     content: msg.content,
     isDm: !msg.guild,
     commandsOnly: DISCORD_COMMANDS_ONLY,
     respondToAllMessages: DISCORD_RESPOND_TO_ALL_MESSAGES,
+    guildMessageMode: resolveGuildMessageMode(msg),
     prefix: DISCORD_PREFIX,
     botMentionRegex,
     hasBotMention: Boolean(client.user && msg.mentions.has(client.user)),
@@ -646,29 +669,60 @@ async function sendChunkedInteractionReply(
   });
 }
 
-async function ensureSlashStatusCommand(): Promise<void> {
-  const definition = {
-    name: 'status',
-    description: 'Show HybridClaw runtime status (only visible to you)',
-  };
+async function ensureSlashCommands(): Promise<void> {
+  interface SlashCommandDefinition {
+    name: string;
+    description: string;
+    options?: Array<{
+      type: ApplicationCommandOptionType.String;
+      name: string;
+      description: string;
+      required?: boolean;
+      choices?: Array<{ name: string; value: string }>;
+    }>;
+  }
+
+  const definitions: SlashCommandDefinition[] = [
+    {
+      name: 'status',
+      description: 'Show HybridClaw runtime status (only visible to you)',
+    },
+    {
+      name: 'channel-mode',
+      description: 'Set this channel to off, mention-only, or free-response',
+      options: [
+        {
+          type: ApplicationCommandOptionType.String,
+          name: 'mode',
+          description: 'Response mode for this channel',
+          required: true,
+          choices: [
+            { name: 'off', value: 'off' },
+            { name: 'mention', value: 'mention' },
+            { name: 'free', value: 'free' },
+          ],
+        },
+      ],
+    },
+  ];
 
   if (!client.application) return;
   await Promise.allSettled(
     [...client.guilds.cache.values()].map(async (guild) => {
       try {
         const existing = await guild.commands.fetch();
-        const current = existing.find((command) => command.name === definition.name);
-        if (!current) {
-          await guild.commands.create(definition);
-          logger.info({ guildId: guild.id }, 'Registered slash command /status');
-          return;
-        }
-        if (current.description !== definition.description) {
-          await guild.commands.edit(current.id, definition);
-          logger.info({ guildId: guild.id }, 'Updated slash command /status');
+        for (const definition of definitions) {
+          const current = existing.find((command) => command.name === definition.name);
+          if (!current) {
+            await guild.commands.create(definition as unknown as ApplicationCommandDataResolvable);
+            logger.info({ guildId: guild.id, command: definition.name }, 'Registered slash command');
+            continue;
+          }
+          await guild.commands.edit(current.id, definition as unknown as ApplicationCommandDataResolvable);
+          logger.info({ guildId: guild.id, command: definition.name }, 'Updated slash command');
         }
       } catch (error) {
-        logger.warn({ error, guildId: guild.id }, 'Failed to register slash command /status');
+        logger.warn({ error, guildId: guild.id }, 'Failed to register Discord slash commands');
       }
     }),
   );
@@ -818,12 +872,12 @@ export function initDiscord(onMessage: MessageHandler, onCommand: CommandHandler
       botMentionRegex = new RegExp(`<@!?${client.user.id}>`, 'g');
     }
     updatePresence();
-    void ensureSlashStatusCommand();
+    void ensureSlashCommands();
   });
 
   client.on('interactionCreate', async (interaction) => {
     if (!interaction.isChatInputCommand()) return;
-    if (interaction.commandName !== 'status') return;
+    if (interaction.commandName !== 'status' && interaction.commandName !== 'channel-mode') return;
 
     if (!isAuthorizedCommandUserId(interaction.user.id)) {
       await sendChunkedInteractionReply(
@@ -836,19 +890,34 @@ export function initDiscord(onMessage: MessageHandler, onCommand: CommandHandler
     const guildId = interaction.guildId ?? null;
     const channelId = interaction.channelId;
     const sessionId = buildSessionIdFromContext(guildId, channelId, interaction.user.id);
+    const args = interaction.commandName === 'status'
+      ? ['status']
+      : (() => {
+          if (!interaction.guildId) return null;
+          const selectedMode = interaction.options.getString('mode', true).trim().toLowerCase();
+          if (selectedMode !== 'off' && selectedMode !== 'mention' && selectedMode !== 'free') return null;
+          return ['channel', 'mode', selectedMode];
+        })();
+    if (!args) {
+      await sendChunkedInteractionReply(
+        interaction,
+        'This command can only be used in a server channel with mode `off`, `mention`, or `free`.',
+      );
+      return;
+    }
     try {
       await commandHandler(
         sessionId,
         guildId,
         channelId,
-        ['status'],
+        args,
         async (text, files) => sendChunkedInteractionReply(interaction, text, files),
       );
     } catch (error) {
       const detail = error instanceof Error ? error.message : String(error);
       logger.error(
         { error, guildId, channelId, userId: interaction.user.id },
-        'Discord slash /status command failed',
+        'Discord slash command failed',
       );
       await sendChunkedInteractionReply(interaction, formatError('Gateway Error', detail));
     }

package/src/config.ts

@@ -62,6 +62,9 @@ export let DISCORD_PRESENCE_INTENT = false;
 export let DISCORD_RESPOND_TO_ALL_MESSAGES = false;
 export let DISCORD_COMMANDS_ONLY = false;
 export let DISCORD_COMMAND_USER_ID = '';
+export let DISCORD_GROUP_POLICY: RuntimeConfig['discord']['groupPolicy'] = 'open';
+export let DISCORD_FREE_RESPONSE_CHANNELS: string[] = [];
+export let DISCORD_GUILDS: RuntimeConfig['discord']['guilds'] = {};
 
 export let HYBRIDAI_BASE_URL = 'https://hybridai.one';
 export let HYBRIDAI_MODEL = 'gpt-5-nano';
@@ -138,6 +141,9 @@ function applyRuntimeConfig(config: RuntimeConfig): void {
   DISCORD_RESPOND_TO_ALL_MESSAGES = config.discord.respondToAllMessages;
   DISCORD_COMMANDS_ONLY = config.discord.commandsOnly;
   DISCORD_COMMAND_USER_ID = config.discord.commandUserId;
+  DISCORD_GROUP_POLICY = config.discord.groupPolicy;
+  DISCORD_FREE_RESPONSE_CHANNELS = [...config.discord.freeResponseChannels];
+  DISCORD_GUILDS = JSON.parse(JSON.stringify(config.discord.guilds)) as RuntimeConfig['discord']['guilds'];
 
   HYBRIDAI_BASE_URL = config.hybridai.baseUrl;
   HYBRIDAI_MODEL = config.hybridai.defaultModel;

package/src/gateway-service.ts

@@ -4,6 +4,9 @@ import { spawnSync } from 'child_process';
 import {
   APP_VERSION,
   DISCORD_COMMANDS_ONLY,
+  DISCORD_FREE_RESPONSE_CHANNELS,
+  DISCORD_GROUP_POLICY,
+  DISCORD_GUILDS,
   DISCORD_RESPOND_TO_ALL_MESSAGES,
   HYBRIDAI_CHATBOT_ID,
   HYBRIDAI_ENABLE_RAG,
@@ -107,6 +110,8 @@ const ORCHESTRATOR_SUBAGENT_ALLOWED_TOOLS = [...BASE_SUBAGENT_ALLOWED_TOOLS, 'de
 const MAX_DELEGATION_TASKS = 6;
 const MAX_DELEGATION_USER_CHARS = 500;
 const MAX_RALPH_ITERATIONS = 64;
+const DISCORD_CHANNEL_MODE_VALUES = new Set(['off', 'mention', 'free']);
+const DISCORD_GROUP_POLICY_VALUES = new Set(['open', 'allowlist', 'disabled']);
 const IMAGE_QUESTION_RE =
   /(what(?:'s| is)? on (?:the )?(?:image|picture|photo|screenshot)|describe (?:this|the) (?:image|picture|photo)|image|picture|photo|screenshot|ocr|diagram|chart|grafik|bild|foto|was steht|was ist auf dem bild)/i;
 const BROWSER_TAB_RE =
@@ -403,10 +408,35 @@ function formatPercent(value: number | null): string {
 
 function resolveActivationModeLabel(): string {
   if (DISCORD_COMMANDS_ONLY) return 'commands-only';
+  if (DISCORD_GROUP_POLICY === 'disabled') return 'disabled';
+  if (DISCORD_GROUP_POLICY === 'allowlist') return 'allowlist';
+  if (DISCORD_FREE_RESPONSE_CHANNELS.length > 0) return `mention + ${DISCORD_FREE_RESPONSE_CHANNELS.length} free channel(s)`;
   if (DISCORD_RESPOND_TO_ALL_MESSAGES) return 'all messages';
   return 'mention';
 }
 
+function resolveGuildChannelMode(guildId: string | null, channelId: string): 'off' | 'mention' | 'free' {
+  if (!guildId) return 'free';
+  if (DISCORD_GROUP_POLICY === 'disabled') return 'off';
+  const guild = DISCORD_GUILDS[guildId];
+  const explicit = guild?.channels[channelId]?.mode;
+  if (DISCORD_GROUP_POLICY === 'allowlist') {
+    return explicit ?? 'off';
+  }
+  if (explicit === 'off' || explicit === 'mention' || explicit === 'free') {
+    return explicit;
+  }
+  if (DISCORD_FREE_RESPONSE_CHANNELS.includes(channelId)) return 'free';
+  if (guild) {
+    const defaultMode = guild.defaultMode;
+    if (defaultMode === 'off' || defaultMode === 'mention' || defaultMode === 'free') {
+      return defaultMode;
+    }
+  }
+  if (DISCORD_RESPOND_TO_ALL_MESSAGES) return 'free';
+  return 'mention';
+}
+
 interface SessionStatusSnapshot {
   promptTokens: number | null;
   completionTokens: number | null;
@@ -1578,9 +1608,12 @@ export async function handleGatewayCommand(req: GatewayCommandRequest): Promise<
         '`model set <name>` — Set model for this session',
         '`model info` — Show current model',
         '`rag [on|off]` — Toggle or set RAG mode',
+        '`channel mode [off|mention|free]` — Set or inspect this Discord channel response mode',
+        '`channel policy [open|allowlist|disabled]` — Set or inspect guild channel policy',
         '`ralph [on|off|set <n>|info]` — Configure Ralph loop (0 off, -1 unlimited)',
         '`clear` — Clear session history',
         '`/status` — Show runtime status (Discord slash command, private to caller)',
+        '`/channel-mode <off|mention|free>` — Set this Discord channel response mode',
         '`sessions` — List active sessions',
         '`schedule add "<cron>" <prompt>` — Add scheduled task',
         '`schedule list` — List scheduled tasks',
@@ -1682,6 +1715,68 @@ export async function handleGatewayCommand(req: GatewayCommandRequest): Promise<
       return badCommand('Usage', 'Usage: `rag [on|off]`');
     }
 
+    case 'channel': {
+      const sub = (req.args[1] || '').toLowerCase();
+      if (sub === 'mode' || !sub) {
+        const guildId = req.guildId;
+        if (!guildId) {
+          return badCommand('Guild Only', '`channel mode` is only available in Discord guild channels.');
+        }
+        const requestedMode = (req.args[sub ? 2 : 1] || '').toLowerCase();
+        if (!requestedMode) {
+          const currentMode = resolveGuildChannelMode(guildId, req.channelId);
+          return infoCommand(
+            'Channel Mode',
+            [
+              `Current mode: \`${currentMode}\``,
+              `Group policy: \`${DISCORD_GROUP_POLICY}\``,
+              `Config path: \`discord.guilds.${guildId}.channels.${req.channelId}.mode\``,
+              'Usage: `channel mode off|mention|free`',
+            ].join('\n'),
+          );
+        }
+        if (!DISCORD_CHANNEL_MODE_VALUES.has(requestedMode)) {
+          return badCommand('Usage', 'Usage: `channel mode off|mention|free`');
+        }
+        const mode = requestedMode as 'off' | 'mention' | 'free';
+        updateRuntimeConfig((draft) => {
+          const guild = draft.discord.guilds[guildId] ?? { defaultMode: 'mention', channels: {} };
+          guild.channels[req.channelId] = { mode };
+          draft.discord.guilds[guildId] = guild;
+        });
+        return plainCommand(
+          `Set channel mode to \`${mode}\` for this channel. (Policy: \`${DISCORD_GROUP_POLICY}\`)`,
+        );
+      }
+
+      if (sub === 'policy') {
+        const requestedPolicy = (req.args[2] || '').toLowerCase();
+        if (!requestedPolicy) {
+          return infoCommand(
+            'Channel Policy',
+            [
+              `Current policy: \`${DISCORD_GROUP_POLICY}\``,
+              'Policies:',
+              '• `open` — all guild channels are active unless a per-channel mode overrides',
+              '• `allowlist` — only channels listed under `discord.guilds.<guild>.channels` are active',
+              '• `disabled` — all guild channels are disabled',
+              'Usage: `channel policy open|allowlist|disabled`',
+            ].join('\n'),
+          );
+        }
+        if (!DISCORD_GROUP_POLICY_VALUES.has(requestedPolicy)) {
+          return badCommand('Usage', 'Usage: `channel policy open|allowlist|disabled`');
+        }
+        const policy = requestedPolicy as 'open' | 'allowlist' | 'disabled';
+        updateRuntimeConfig((draft) => {
+          draft.discord.groupPolicy = policy;
+        });
+        return plainCommand(`Discord group policy set to \`${policy}\`.`);
+      }
+
+      return badCommand('Usage', 'Usage: `channel mode [off|mention|free]` or `channel policy [open|allowlist|disabled]`');
+    }
+
     case 'ralph': {
       const sub = (req.args[1] || '').toLowerCase();
       if (!sub || sub === 'info' || sub === 'status') {

package/src/runtime-config.ts

@@ -24,6 +24,14 @@ export interface RuntimeSecurityConfig {
   trustModelAcceptedBy: string;
 }
 
+export type DiscordGroupPolicy = 'open' | 'allowlist' | 'disabled';
+export type DiscordChannelMode = 'off' | 'mention' | 'free';
+
+export interface RuntimeDiscordGuildConfig {
+  defaultMode: DiscordChannelMode;
+  channels: Record<string, { mode: DiscordChannelMode }>;
+}
+
 export interface RuntimeConfig {
   version: number;
   security: RuntimeSecurityConfig;
@@ -37,6 +45,9 @@ export interface RuntimeConfig {
     respondToAllMessages: boolean;
     commandsOnly: boolean;
     commandUserId: string;
+    groupPolicy: DiscordGroupPolicy;
+    freeResponseChannels: string[];
+    guilds: Record<string, RuntimeDiscordGuildConfig>;
   };
   hybridai: {
     baseUrl: string;
@@ -143,6 +154,9 @@ const DEFAULT_RUNTIME_CONFIG: RuntimeConfig = {
     respondToAllMessages: false,
     commandsOnly: false,
     commandUserId: '',
+    groupPolicy: 'open',
+    freeResponseChannels: [],
+    guilds: {},
   },
   hybridai: {
     baseUrl: 'https://hybridai.one',
@@ -312,6 +326,60 @@ function normalizeStringArray(value: unknown, fallback: string[]): string[] {
   return fallback;
 }
 
+function normalizeDiscordGroupPolicy(value: unknown, fallback: DiscordGroupPolicy): DiscordGroupPolicy {
+  if (typeof value !== 'string') return fallback;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === 'open' || normalized === 'allowlist' || normalized === 'disabled') {
+    return normalized;
+  }
+  return fallback;
+}
+
+function normalizeDiscordChannelMode(value: unknown, fallback: DiscordChannelMode): DiscordChannelMode {
+  if (typeof value !== 'string') return fallback;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === 'off' || normalized === 'mention' || normalized === 'free') return normalized;
+  if (normalized === 'free-response' || normalized === 'free_response') return 'free';
+  return fallback;
+}
+
+function normalizeDiscordGuildConfig(
+  value: unknown,
+  fallback: RuntimeDiscordGuildConfig,
+): RuntimeDiscordGuildConfig {
+  if (!isRecord(value)) return fallback;
+  const defaultMode = normalizeDiscordChannelMode(value.defaultMode, fallback.defaultMode);
+  const rawChannels = isRecord(value.channels) ? value.channels : {};
+  const channels: Record<string, { mode: DiscordChannelMode }> = {};
+  for (const [rawChannelId, rawChannelConfig] of Object.entries(rawChannels)) {
+    const channelId = rawChannelId.trim();
+    if (!channelId) continue;
+    if (typeof rawChannelConfig === 'string') {
+      channels[channelId] = { mode: normalizeDiscordChannelMode(rawChannelConfig, defaultMode) };
+      continue;
+    }
+    if (!isRecord(rawChannelConfig)) continue;
+    channels[channelId] = { mode: normalizeDiscordChannelMode(rawChannelConfig.mode, defaultMode) };
+  }
+
+  return { defaultMode, channels };
+}
+
+function normalizeDiscordGuildMap(
+  value: unknown,
+  fallback: Record<string, RuntimeDiscordGuildConfig>,
+): Record<string, RuntimeDiscordGuildConfig> {
+  if (!isRecord(value)) return fallback;
+  const guilds: Record<string, RuntimeDiscordGuildConfig> = {};
+  for (const [rawGuildId, rawGuildConfig] of Object.entries(value)) {
+    const guildId = rawGuildId.trim();
+    if (!guildId) continue;
+    const fallbackGuild = fallback[guildId] ?? { defaultMode: 'mention', channels: {} };
+    guilds[guildId] = normalizeDiscordGuildConfig(rawGuildConfig, fallbackGuild);
+  }
+  return guilds;
+}
+
 function normalizeLogLevel(value: unknown, fallback: LogLevel): LogLevel {
   const normalized = normalizeString(value, fallback, { allowEmpty: false }).toLowerCase();
   if (KNOWN_LOG_LEVELS.has(normalized)) return normalized as LogLevel;
@@ -419,6 +487,15 @@ function normalizeRuntimeConfig(patch?: DeepPartial<RuntimeConfig>): RuntimeConf
         DEFAULT_RUNTIME_CONFIG.discord.commandUserId,
         { allowEmpty: true },
       ),
+      groupPolicy: normalizeDiscordGroupPolicy(
+        rawDiscord.groupPolicy,
+        DEFAULT_RUNTIME_CONFIG.discord.groupPolicy,
+      ),
+      freeResponseChannels: normalizeStringArray(
+        rawDiscord.freeResponseChannels,
+        DEFAULT_RUNTIME_CONFIG.discord.freeResponseChannels,
+      ),
+      guilds: normalizeDiscordGuildMap(rawDiscord.guilds, DEFAULT_RUNTIME_CONFIG.discord.guilds),
     },
     hybridai: {
       baseUrl: hybridBaseUrl,

package/tests/discord.basic.test.ts

@@ -1,6 +1,7 @@
 import { expect, test } from 'vitest';
 
 import { buildResponseText } from '../src/channels/discord/delivery.js';
+import { isTrigger, parseCommand } from '../src/channels/discord/inbound.js';
 import { rewriteUserMentions, type MentionLookup } from '../src/channels/discord/mentions.js';
 
 function createLookup(entries: Record<string, string[]>): MentionLookup {
@@ -41,3 +42,54 @@ test('buildResponseText leaves text unchanged when no tools were used', () => {
   const output = buildResponseText('Done.');
   expect(output).toBe('Done.');
 });
+
+test('isTrigger blocks non-command chatter when channel mode is off', () => {
+  const shouldTrigger = isTrigger({
+    content: 'hello',
+    isDm: false,
+    commandsOnly: false,
+    respondToAllMessages: false,
+    guildMessageMode: 'off',
+    prefix: '!claw',
+    botMentionRegex: null,
+    hasBotMention: false,
+  });
+  expect(shouldTrigger).toBe(false);
+});
+
+test('isTrigger still allows prefixed commands when channel mode is off', () => {
+  const shouldTrigger = isTrigger({
+    content: '!claw status',
+    isDm: false,
+    commandsOnly: false,
+    respondToAllMessages: false,
+    guildMessageMode: 'off',
+    prefix: '!claw',
+    botMentionRegex: null,
+    hasBotMention: false,
+  });
+  expect(shouldTrigger).toBe(true);
+});
+
+test('isTrigger allows free-response mode in guild channels', () => {
+  const shouldTrigger = isTrigger({
+    content: 'hello',
+    isDm: false,
+    commandsOnly: false,
+    respondToAllMessages: false,
+    guildMessageMode: 'free',
+    prefix: '!claw',
+    botMentionRegex: null,
+    hasBotMention: false,
+  });
+  expect(shouldTrigger).toBe(true);
+});
+
+test('parseCommand recognizes channel command namespace', () => {
+  const parsed = parseCommand('!claw channel mode free', null, '!claw');
+  expect(parsed).toEqual({
+    isCommand: true,
+    command: 'channel',
+    args: ['mode', 'free'],
+  });
+});