@hybridaione/hybridclaw 0.2.2 → 0.2.6

package/dist/channels/discord/runtime.js

@@ -1,18 +1,22 @@
-import { ActivityType, Client, GatewayIntentBits, Partials, } from 'discord.js';
-import { DISCORD_COMMAND_USER_ID, DISCORD_COMMANDS_ONLY, DISCORD_GUILD_MEMBERS_INTENT, DISCORD_PRESENCE_INTENT, DISCORD_PREFIX, DISCORD_RESPOND_TO_ALL_MESSAGES, DISCORD_TOKEN, } from '../../config.js';
+import { ApplicationCommandOptionType, Client, GatewayIntentBits, Partials, } from 'discord.js';
+import { DISCORD_ACK_REACTION, DISCORD_ACK_REACTION_SCOPE, DISCORD_COMMAND_USER_ID, DISCORD_COMMANDS_ONLY, DISCORD_DEBOUNCE_MS, DISCORD_FREE_RESPONSE_CHANNELS, DISCORD_GROUP_POLICY, DISCORD_GUILD_MEMBERS_INTENT, DISCORD_GUILDS, DISCORD_HUMAN_DELAY, DISCORD_LIFECYCLE_REACTIONS, DISCORD_MAX_CONCURRENT_PER_CHANNEL, DISCORD_PREFIX, DISCORD_PRESENCE_INTENT, DISCORD_RATE_LIMIT_EXEMPT_ROLES, DISCORD_RATE_LIMIT_PER_USER, DISCORD_REMOVE_ACK_AFTER_REPLY, DISCORD_RESPOND_TO_ALL_MESSAGES, DISCORD_SELF_PRESENCE, DISCORD_SUPPRESS_PATTERNS, DISCORD_TOKEN, DISCORD_TYPING_MODE, } from '../../config.js';
+import { logger } from '../../logger.js';
 import { buildAttachmentContext } from './attachments.js';
+import { DEFAULT_DEBOUNCE_MAX_BUFFER, resolveInboundDebounceMs, shouldDebounceInbound, } from './debounce.js';
+import { formatError, prepareChunkedPayloads, sendChunkedDirectReply as sendChunkedDirectReplyFromDelivery, sendChunkedInteractionReply as sendChunkedInteractionReplyFromDelivery, sendChunkedReply as sendChunkedReplyFromDelivery, } from './delivery.js';
 import { buildSessionIdFromContext as buildSessionIdFromContextInbound, cleanIncomingContent as cleanIncomingContentInbound, hasPrefixInvocation as hasPrefixInvocationInbound, isTrigger as isTriggerInbound, parseCommand as parseCommandInbound, } from './inbound.js';
 import { addMentionAlias, extractMentionAliasHints, normalizeMentionAlias, } from './mentions.js';
-import { formatError, prepareChunkedPayloads, sendChunkedDirectReply as sendChunkedDirectReplyFromDelivery, sendChunkedInteractionReply as sendChunkedInteractionReplyFromDelivery, sendChunkedReply as sendChunkedReplyFromDelivery, } from './delivery.js';
-import { createDiscordToolActionRunner, } from './tool-actions.js';
+import { DiscordAutoPresenceController, } from './presence.js';
+import { SlidingWindowRateLimiter } from './rate-limiter.js';
+import { addAckReaction, LifecycleReactionController, } from './reactions.js';
 import { DiscordStreamManager } from './stream.js';
-import { logger } from '../../logger.js';
+import { createDiscordToolActionRunner, } from './tool-actions.js';
+import { createTypingController } from './typing.js';
 let client;
 let messageHandler;
 let commandHandler;
 let activeConversationRuns = 0;
 let botMentionRegex = null;
-const MESSAGE_DEBOUNCE_MS = 2_500;
 const DISCORD_RETRY_MAX_ATTEMPTS = 3;
 const DISCORD_RETRY_BASE_DELAY_MS = 500;
 const GUILD_INBOUND_HISTORY_LIMIT = 20;
@@ -22,7 +26,32 @@ const PARTICIPANT_MEMORY_MAX_CHANNELS = 200;
 const PARTICIPANT_MEMORY_MAX_USERS_PER_CHANNEL = 200;
 const PARTICIPANT_MEMORY_MAX_ALIASES_PER_USER = 8;
 const MAX_PRESENCE_CACHE_USERS = 5_000;
+const RATE_LIMIT_NOTIFY_COOLDOWN_MS = 12_000;
+const CONCURRENCY_RETRY_DELAY_MS = 250;
+const PRESENCE_WINDOW_MS = 5 * 60_000;
+const PRESENCE_DEGRADED_DURATION_MS = 45_000;
+const PRESENCE_EXHAUSTED_ERROR_RE = /(api down|unavailable|rate limit|too many active containers|quota|token limit|timeout)/i;
+const FRIENDLY_RATE_LIMIT_MESSAGE = "You're sending messages too fast — give me a moment to catch up!";
+const READ_WITHOUT_REPLY_RE = /^(thanks|thank you|thx|ty|got it|ok|okay|cool|perfect|awesome|sounds good|roger)[!. ]*$/i;
+const READ_WITHOUT_REPLY_PROBABILITY = 0.6;
+const STARTUP_STAGGER_WINDOW_MS = 120_000;
+const STARTUP_STAGGER_MIN_DELAY_MS = 500;
+const STARTUP_STAGGER_MAX_DELAY_MS = 3_500;
+const SELECTIVE_SILENCE_BASE_PROBABILITY = 0.25;
+const SELECTIVE_SILENCE_ACTIVE_CHAT_PROBABILITY = 0.5;
+const SELECTIVE_SILENCE_RECENT_WINDOW_MS = 60_000;
+const NIGHT_HOURS_START = 22;
+const NIGHT_HOURS_END = 7;
+const CONVERSATION_COOLDOWN_RESET_MS = 20 * 60_000;
+const CONVERSATION_COOLDOWN_THRESHOLD = 5;
+const CONVERSATION_COOLDOWN_MAX_FACTOR = 2.5;
 const discordPresenceCache = new Map();
+const userRateLimiter = new SlidingWindowRateLimiter(60_000);
+const recentConversationMetrics = [];
+let consecutiveConversationFailures = 0;
+let presenceController = null;
+let startupConnectedAtMs = 0;
+const conversationExchangeByKey = new Map();
 function setDiscordPresence(userId, data) {
     discordPresenceCache.set(userId, data);
     if (discordPresenceCache.size > MAX_PRESENCE_CACHE_USERS) {
@@ -90,7 +119,8 @@ function buildPendingHistoryContext(entries) {
         const line = summarizePendingHistoryEntry(entries[i]);
         if (!line)
             continue;
-        if (totalChars + line.length > GUILD_INBOUND_HISTORY_MAX_CHARS && selected.length > 0)
+        if (totalChars + line.length > GUILD_INBOUND_HISTORY_MAX_CHARS &&
+            selected.length > 0)
             break;
         selected.push(line);
         totalChars += line.length + 1;
@@ -110,7 +140,9 @@ async function buildInboundHistorySnapshot(msg, excludeMessageIds) {
     if (!msg.guild || !('messages' in msg.channel))
         return { entries: [], context: '' };
     try {
-        const recentMessages = await msg.channel.messages.fetch({ limit: GUILD_INBOUND_HISTORY_LIMIT });
+        const recentMessages = await msg.channel.messages.fetch({
+            limit: GUILD_INBOUND_HISTORY_LIMIT,
+        });
         const entries = [];
         let hiddenTextCount = 0;
         let hiddenBotTextCount = 0;
@@ -119,7 +151,9 @@ async function buildInboundHistorySnapshot(msg, excludeMessageIds) {
             if (plainText)
                 return plainText;
             const embedChunks = recent.embeds
-                .map((embed) => [embed.title?.trim(), embed.description?.trim()].filter(Boolean).join(' — '))
+                .map((embed) => [embed.title?.trim(), embed.description?.trim()]
+                .filter(Boolean)
+                .join(' — '))
                 .map((part) => part.trim())
                 .filter(Boolean)
                 .slice(0, 3);
@@ -133,7 +167,9 @@ async function buildInboundHistorySnapshot(msg, excludeMessageIds) {
             if (attachmentNames.length > 0) {
                 return `[attachments] ${attachmentNames.join(', ')}`;
             }
-            const systemContent = recent.system ? (recent.cleanContent || '').trim() : '';
+            const systemContent = recent.system
+                ? (recent.cleanContent || '').trim()
+                : '';
             if (systemContent)
                 return `[system] ${systemContent}`;
             hiddenTextCount += 1;
@@ -157,7 +193,9 @@ async function buildInboundHistorySnapshot(msg, excludeMessageIds) {
                 username: recent.author.username || 'user',
                 displayName: recent.member?.displayName || null,
                 isBot: Boolean(recent.author.bot),
-                timestampMs: Number.isFinite(recent.createdTimestamp) ? recent.createdTimestamp : 0,
+                timestampMs: Number.isFinite(recent.createdTimestamp)
+                    ? recent.createdTimestamp
+                    : 0,
                 content,
             });
         }
@@ -314,29 +352,101 @@ function isAuthorizedCommandUserId(userId) {
 function buildSessionIdFromContext(guildId, channelId, userId) {
     return buildSessionIdFromContextInbound(guildId, channelId, userId);
 }
-function isTrigger(msg) {
+function resolveGuildMessageMode(msg) {
+    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 resolveChannelBehavior(msg) {
+    const guildConfig = msg.guild ? DISCORD_GUILDS[msg.guild.id] : undefined;
+    const channelConfig = guildConfig?.channels[msg.channelId];
+    return {
+        guildMessageMode: resolveGuildMessageMode(msg),
+        typingMode: channelConfig?.typingMode ?? DISCORD_TYPING_MODE,
+        debounceMs: resolveInboundDebounceMs(DISCORD_DEBOUNCE_MS, channelConfig?.debounceMs),
+        ackReaction: (channelConfig?.ackReaction ?? DISCORD_ACK_REACTION).trim() ||
+            DISCORD_ACK_REACTION,
+        ackReactionScope: channelConfig?.ackReactionScope ?? DISCORD_ACK_REACTION_SCOPE,
+        removeAckAfterReply: channelConfig?.removeAckAfterReply ?? DISCORD_REMOVE_ACK_AFTER_REPLY,
+        humanDelay: channelConfig?.humanDelay ?? DISCORD_HUMAN_DELAY,
+        rateLimitPerUser: Math.max(0, channelConfig?.rateLimitPerUser ?? DISCORD_RATE_LIMIT_PER_USER),
+        suppressPatterns: channelConfig?.suppressPatterns ?? DISCORD_SUPPRESS_PATTERNS,
+        maxConcurrentPerChannel: Math.max(1, channelConfig?.maxConcurrentPerChannel ??
+            DISCORD_MAX_CONCURRENT_PER_CHANNEL),
+    };
+}
+function isTrigger(msg, behavior) {
     return isTriggerInbound({
         content: msg.content,
         isDm: !msg.guild,
         commandsOnly: DISCORD_COMMANDS_ONLY,
         respondToAllMessages: DISCORD_RESPOND_TO_ALL_MESSAGES,
+        guildMessageMode: behavior.guildMessageMode,
         prefix: DISCORD_PREFIX,
         botMentionRegex,
         hasBotMention: Boolean(client.user && msg.mentions.has(client.user)),
+        suppressPatterns: behavior.suppressPatterns,
     });
 }
+function shouldApplyAckReaction(msg, behavior) {
+    const scope = behavior.ackReactionScope;
+    if (scope === 'off')
+        return false;
+    if (scope === 'all')
+        return true;
+    if (scope === 'direct')
+        return !msg.guild;
+    if (!msg.guild || !client.user)
+        return false;
+    return msg.mentions.has(client.user);
+}
+function isRateLimitExempt(msg) {
+    if (msg.author.id === DISCORD_COMMAND_USER_ID.trim())
+        return true;
+    if (!msg.guild)
+        return false;
+    if (!msg.member || DISCORD_RATE_LIMIT_EXEMPT_ROLES.length === 0)
+        return false;
+    const exemptByName = new Set(DISCORD_RATE_LIMIT_EXEMPT_ROLES.map((role) => role.trim().toLowerCase()).filter(Boolean));
+    if (exemptByName.size === 0)
+        return false;
+    for (const role of msg.member.roles.cache.values()) {
+        const normalized = role.name.trim().toLowerCase();
+        if (exemptByName.has(normalized))
+            return true;
+    }
+    return false;
+}
 function parseCommand(content) {
     return parseCommandInbound(content, botMentionRegex, DISCORD_PREFIX);
 }
 function isRetryableDiscordError(error) {
     const maybe = error;
     const status = maybe.status ?? maybe.httpStatus;
-    return status === 429 || (typeof status === 'number' && status >= 500 && status <= 599);
+    return (status === 429 ||
+        (typeof status === 'number' && status >= 500 && status <= 599));
 }
 function retryDelayMs(error, fallbackMs) {
     const maybe = error;
     const retryAfterSeconds = maybe.retryAfter ?? maybe.data?.retry_after;
-    if (typeof retryAfterSeconds === 'number' && Number.isFinite(retryAfterSeconds) && retryAfterSeconds > 0) {
+    if (typeof retryAfterSeconds === 'number' &&
+        Number.isFinite(retryAfterSeconds) &&
+        retryAfterSeconds > 0) {
         return Math.max(50, Math.ceil(retryAfterSeconds * 1_000));
     }
     return fallbackMs + Math.floor(Math.random() * 250);
@@ -350,7 +460,8 @@ async function withDiscordRetry(label, fn) {
             return await fn();
         }
         catch (error) {
-            if (attempt >= DISCORD_RETRY_MAX_ATTEMPTS || !isRetryableDiscordError(error)) {
+            if (attempt >= DISCORD_RETRY_MAX_ATTEMPTS ||
+                !isRetryableDiscordError(error)) {
                 throw error;
             }
             const waitMs = retryDelayMs(error, delayMs);
@@ -386,7 +497,9 @@ function buildChannelInfoContext(msg) {
     if (channelTopic) {
         lines.push(`- channel_topic: ${channelTopic}`);
     }
-    const parentName = typeof namedChannel.parent?.name === 'string' ? namedChannel.parent.name.trim() : '';
+    const parentName = typeof namedChannel.parent?.name === 'string'
+        ? namedChannel.parent.name.trim()
+        : '';
     if (parentName) {
         lines.push(`- parent_channel: ${parentName}`);
     }
@@ -395,7 +508,9 @@ function buildChannelInfoContext(msg) {
 }
 async function buildReplyContext(msg) {
     const blocks = [];
-    if ('isThread' in msg.channel && typeof msg.channel.isThread === 'function' && msg.channel.isThread()) {
+    if ('isThread' in msg.channel &&
+        typeof msg.channel.isThread === 'function' &&
+        msg.channel.isThread()) {
         try {
             const starter = await msg.channel.fetchStarterMessage();
             if (starter) {
@@ -427,70 +542,22 @@ async function buildReplyContext(msg) {
         return '';
     return `${blocks.join('\n\n')}\n\n`;
 }
-async function addProcessingReaction(msg) {
-    if (!client.user)
-        return async () => { };
-    const botUserId = client.user.id;
-    try {
-        await withDiscordRetry('react', () => msg.react('👀'));
-    }
-    catch (error) {
-        logger.debug({ error, channelId: msg.channelId, messageId: msg.id }, 'Failed to add processing reaction');
-        return async () => { };
-    }
-    return async () => {
-        try {
-            const reaction = msg.reactions.resolve('👀');
-            if (!reaction)
-                return;
-            await withDiscordRetry('reaction-remove', () => reaction.users.remove(botUserId));
-        }
-        catch (error) {
-            logger.debug({ error, channelId: msg.channelId, messageId: msg.id }, 'Failed to remove processing reaction');
-        }
-    };
-}
-function startTypingLoop(msg) {
-    let stopped = false;
-    const sendTyping = async () => {
-        if (stopped)
-            return;
-        if (!('sendTyping' in msg.channel))
-            return;
-        try {
-            await msg.channel.sendTyping();
-        }
-        catch (error) {
-            logger.debug({ error, channelId: msg.channelId }, 'Failed to send typing indicator');
-        }
-    };
-    void sendTyping();
-    const timer = setInterval(() => {
-        void sendTyping();
-    }, 8_000);
-    return {
-        stop: () => {
-            if (stopped)
-                return;
-            stopped = true;
-            clearInterval(timer);
-        },
-    };
-}
-async function sendChunkedReply(msg, text, files, mentionLookup) {
+async function sendChunkedReply(msg, text, files, mentionLookup, humanDelay) {
     await sendChunkedReplyFromDelivery({
         msg,
         text,
         withRetry: withDiscordRetry,
+        ...(humanDelay ? { humanDelay } : {}),
         ...(files ? { files } : {}),
         ...(mentionLookup ? { mentionLookup } : {}),
     });
 }
-async function sendChunkedDirectReply(msg, text, files, mentionLookup) {
+async function sendChunkedDirectReply(msg, text, files, mentionLookup, humanDelay) {
     await sendChunkedDirectReplyFromDelivery({
         msg,
         text,
         withRetry: withDiscordRetry,
+        ...(humanDelay ? { humanDelay } : {}),
         ...(files ? { files } : {}),
         ...(mentionLookup ? { mentionLookup } : {}),
     });
@@ -503,52 +570,177 @@ async function sendChunkedInteractionReply(interaction, text, files) {
         ...(files ? { files } : {}),
     });
 }
-async function ensureSlashStatusCommand() {
-    const definition = {
-        name: 'status',
-        description: 'Show HybridClaw runtime status (only visible to you)',
-    };
+async function ensureSlashCommands() {
+    const definitions = [
+        {
+            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' },
+                    ],
+                },
+            ],
+        },
+        {
+            name: 'channel-policy',
+            description: 'Set guild channel policy to open, allowlist, or disabled',
+            options: [
+                {
+                    type: ApplicationCommandOptionType.String,
+                    name: 'policy',
+                    description: 'Guild channel policy',
+                    required: true,
+                    choices: [
+                        { name: 'open', value: 'open' },
+                        { name: 'allowlist', value: 'allowlist' },
+                        { name: 'disabled', value: 'disabled' },
+                    ],
+                },
+            ],
+        },
+    ];
     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) {
+            for (const definition of definitions) {
+                const current = existing.find((command) => command.name === definition.name);
+                if (!current) {
+                    await guild.commands.create(definition);
+                    logger.info({ guildId: guild.id, command: definition.name }, 'Registered slash command');
+                    continue;
+                }
                 await guild.commands.edit(current.id, definition);
-                logger.info({ guildId: guild.id }, 'Updated slash command /status');
+                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');
         }
     }));
 }
-function updatePresence() {
-    if (!client.user)
-        return;
-    if (activeConversationRuns > 0) {
-        client.user.setPresence({
-            activities: [{ name: 'Thinking...', type: ActivityType.Playing }],
-            status: 'online',
-        });
+function trimRecentConversationMetrics(nowMs = Date.now()) {
+    const cutoff = nowMs - PRESENCE_WINDOW_MS;
+    while (recentConversationMetrics.length > 0 &&
+        recentConversationMetrics[0].atMs < cutoff) {
+        recentConversationMetrics.shift();
+    }
+}
+function recordConversationMetric(params) {
+    const nowMs = Date.now();
+    const errorText = params.error instanceof Error
+        ? params.error.message
+        : String(params.error || '');
+    const exhaustedHint = !params.ok && PRESENCE_EXHAUSTED_ERROR_RE.test(errorText);
+    if (params.ok) {
+        consecutiveConversationFailures = 0;
+    }
+    else {
+        consecutiveConversationFailures += 1;
+    }
+    recentConversationMetrics.push({
+        atMs: nowMs,
+        durationMs: Math.max(0, Math.floor(params.durationMs)),
+        ok: params.ok,
+        exhaustedHint,
+    });
+    trimRecentConversationMetrics(nowMs);
+}
+function resolvePresenceHealthState() {
+    trimRecentConversationMetrics();
+    if (activeConversationRuns >= 4)
+        return 'degraded';
+    if (consecutiveConversationFailures >= 3)
+        return 'exhausted';
+    if (recentConversationMetrics.some((entry) => entry.exhaustedHint))
+        return 'exhausted';
+    if (recentConversationMetrics.length === 0)
+        return 'healthy';
+    const totalDuration = recentConversationMetrics.reduce((sum, entry) => sum + entry.durationMs, 0);
+    const avgDuration = totalDuration / recentConversationMetrics.length;
+    const failureCount = recentConversationMetrics.filter((entry) => !entry.ok).length;
+    const errorRate = failureCount / recentConversationMetrics.length;
+    if (errorRate >= 0.25 || avgDuration >= PRESENCE_DEGRADED_DURATION_MS)
+        return 'degraded';
+    return 'healthy';
+}
+function randomIntInRange(minMs, maxMs) {
+    const lo = Math.floor(Math.max(0, minMs));
+    const hi = Math.floor(Math.max(lo, maxMs));
+    if (hi <= lo)
+        return lo;
+    return lo + Math.floor(Math.random() * (hi - lo + 1));
+}
+function isNightOrWeekend(now) {
+    const day = now.getDay();
+    const hour = now.getHours();
+    const weekend = day === 0 || day === 6;
+    const night = hour >= NIGHT_HOURS_START || hour < NIGHT_HOURS_END;
+    return weekend || night;
+}
+function buildConversationCooldownKey(channelId, userId) {
+    return `${channelId}:${userId}`;
+}
+function resolveHumanDelayWithBehavior(base, cooldownKey) {
+    if (base.mode === 'off')
+        return base;
+    const now = new Date();
+    let factor = isNightOrWeekend(now) ? 1.5 : 1;
+    const record = conversationExchangeByKey.get(cooldownKey);
+    if (record) {
+        const elapsedMs = Date.now() - record.lastAtMs;
+        if (elapsedMs > CONVERSATION_COOLDOWN_RESET_MS) {
+            conversationExchangeByKey.delete(cooldownKey);
+        }
+        else if (record.count > CONVERSATION_COOLDOWN_THRESHOLD) {
+            const extra = Math.min(CONVERSATION_COOLDOWN_MAX_FACTOR - 1, (record.count - CONVERSATION_COOLDOWN_THRESHOLD) * 0.12);
+            factor += Math.max(0, extra);
+        }
+    }
+    if (factor <= 1)
+        return base;
+    const minMs = Math.round((base.minMs ?? 800) * factor);
+    const maxMs = Math.round((base.maxMs ?? 2_500) * factor);
+    return {
+        mode: 'custom',
+        minMs,
+        maxMs: Math.max(minMs, maxMs),
+    };
+}
+function noteConversationExchange(cooldownKey) {
+    const nowMs = Date.now();
+    const existing = conversationExchangeByKey.get(cooldownKey);
+    if (!existing || nowMs - existing.lastAtMs > CONVERSATION_COOLDOWN_RESET_MS) {
+        conversationExchangeByKey.set(cooldownKey, { count: 1, lastAtMs: nowMs });
         return;
     }
-    client.user.setPresence({
-        activities: [{ name: `in ${client.guilds.cache.size} servers`, type: ActivityType.Listening }],
-        status: 'online',
+    conversationExchangeByKey.set(cooldownKey, {
+        count: existing.count + 1,
+        lastAtMs: nowMs,
     });
 }
+function pickReadWithoutReplyEmoji() {
+    return Math.random() < 0.7 ? '👍' : '✅';
+}
 export function initDiscord(onMessage, onCommand) {
     messageHandler = onMessage;
     commandHandler = onCommand;
     const pendingBatches = new Map();
     const inFlightByMessageId = new Map();
+    const channelConcurrencyById = new Map();
     const negativeFeedbackByChannel = new Map();
     const participantMemoryByChannel = new Map();
     const touchParticipantMemoryChannel = (channelId) => {
@@ -623,6 +815,99 @@ export function initDiscord(onMessage, onCommand) {
             rememberParticipantAliasForChannel(msg.channelId, hint.userId, hint.alias);
         }
     };
+    const waitForChannelConcurrencySlot = async (channelId, maxConcurrent, abortSignal) => {
+        const boundedMax = Math.max(1, Math.floor(maxConcurrent));
+        while ((channelConcurrencyById.get(channelId) ?? 0) >= boundedMax) {
+            if (abortSignal?.aborted) {
+                throw new Error('Conversation aborted while waiting for channel concurrency slot.');
+            }
+            await new Promise((resolve) => setTimeout(resolve, CONCURRENCY_RETRY_DELAY_MS));
+        }
+        if (abortSignal?.aborted) {
+            throw new Error('Conversation aborted before acquiring channel concurrency slot.');
+        }
+        channelConcurrencyById.set(channelId, (channelConcurrencyById.get(channelId) ?? 0) + 1);
+        return () => {
+            const current = channelConcurrencyById.get(channelId) ?? 0;
+            const next = Math.max(0, current - 1);
+            if (next === 0) {
+                channelConcurrencyById.delete(channelId);
+            }
+            else {
+                channelConcurrencyById.set(channelId, next);
+            }
+        };
+    };
+    const enforcePerUserRateLimit = async (msg, behavior) => {
+        const limit = Math.max(0, Math.floor(behavior.rateLimitPerUser));
+        if (limit === 0)
+            return true;
+        if (isRateLimitExempt(msg))
+            return true;
+        const key = `${msg.channelId}:${msg.author.id}`;
+        const decision = userRateLimiter.check(key, limit);
+        if (decision.allowed)
+            return true;
+        if (userRateLimiter.shouldNotify(key, RATE_LIMIT_NOTIFY_COOLDOWN_MS)) {
+            try {
+                await withDiscordRetry('rate-limit-reply', () => msg.reply({ content: FRIENDLY_RATE_LIMIT_MESSAGE }));
+            }
+            catch (error) {
+                logger.debug({ error, channelId: msg.channelId, userId: msg.author.id }, 'Failed to send rate-limit warning');
+            }
+        }
+        return false;
+    };
+    const maybeHandleReadWithoutReply = async (msg, content) => {
+        if (!content.trim())
+            return false;
+        if (msg.attachments.size > 0)
+            return false;
+        if (hasPrefixInvocation(msg.content || ''))
+            return false;
+        if (client.user && msg.mentions.has(client.user))
+            return false;
+        if (content.trim().length > 80)
+            return false;
+        if (!READ_WITHOUT_REPLY_RE.test(content.trim()))
+            return false;
+        if (Math.random() > READ_WITHOUT_REPLY_PROBABILITY)
+            return false;
+        try {
+            await withDiscordRetry('reaction-read-without-reply', () => msg.react(pickReadWithoutReplyEmoji()));
+            return true;
+        }
+        catch (error) {
+            logger.debug({ error, channelId: msg.channelId, messageId: msg.id }, 'Failed read-without-reply reaction');
+            return false;
+        }
+    };
+    const shouldSelectivelySilence = (params) => {
+        if (!params.sourceItem.msg.guild)
+            return false;
+        if (params.behavior.guildMessageMode !== 'free')
+            return false;
+        if (params.sourceItem.wasExplicitlyAddressed)
+            return false;
+        const nowMs = Date.now();
+        const peerMessages = params.inboundHistory
+            .filter((entry) => !entry.isBot &&
+            entry.userId !== params.sourceItem.msg.author.id &&
+            nowMs - entry.timestampMs <= SELECTIVE_SILENCE_RECENT_WINDOW_MS)
+            .sort((a, b) => a.timestampMs - b.timestampMs);
+        if (peerMessages.length === 0)
+            return false;
+        const sourceText = params.sourceItem.content.trim();
+        const asksQuestion = sourceText.includes('?');
+        const latestPeer = peerMessages[peerMessages.length - 1]?.content?.trim().toLowerCase() ||
+            '';
+        const peerLooksLikeAnswer = latestPeer.length >= 24 ||
+            /\\b(you can|try|use|it is|it's|because|should|here|answer|fix)\\b/.test(latestPeer);
+        const probability = asksQuestion && peerLooksLikeAnswer
+            ? SELECTIVE_SILENCE_ACTIVE_CHAT_PROBABILITY
+            : SELECTIVE_SILENCE_BASE_PROBABILITY;
+        return Math.random() < probability;
+    };
     const intents = [
         GatewayIntentBits.Guilds,
         GatewayIntentBits.GuildMessages,
@@ -636,7 +921,12 @@ export function initDiscord(onMessage, onCommand) {
         intents.push(GatewayIntentBits.GuildPresences);
     client = new Client({
         intents,
-        partials: [Partials.Channel, Partials.Message, Partials.Reaction, Partials.User],
+        partials: [
+            Partials.Channel,
+            Partials.Message,
+            Partials.Reaction,
+            Partials.User,
+        ],
     });
     client.on('presenceUpdate', (_oldPresence, nextPresence) => {
         const userId = nextPresence.userId || nextPresence.user?.id;
@@ -654,17 +944,27 @@ export function initDiscord(onMessage, onCommand) {
     });
     client.on('clientReady', () => {
         logger.info({ user: client.user?.tag }, 'Discord bot connected');
+        startupConnectedAtMs = Date.now();
         if (client.user) {
             botMentionRegex = new RegExp(`<@!?${client.user.id}>`, 'g');
         }
-        updatePresence();
-        void ensureSlashStatusCommand();
+        presenceController?.stop();
+        presenceController = new DiscordAutoPresenceController({
+            client,
+            getConfig: () => DISCORD_SELF_PRESENCE,
+            resolveState: resolvePresenceHealthState,
+        });
+        presenceController.start();
+        void ensureSlashCommands();
     });
     client.on('interactionCreate', async (interaction) => {
         if (!interaction.isChatInputCommand())
             return;
-        if (interaction.commandName !== 'status')
+        if (interaction.commandName !== 'status' &&
+            interaction.commandName !== 'channel-mode' &&
+            interaction.commandName !== 'channel-policy') {
             return;
+        }
         if (!isAuthorizedCommandUserId(interaction.user.id)) {
             await sendChunkedInteractionReply(interaction, 'You are not authorized to run commands for this bot.');
             return;
@@ -672,12 +972,45 @@ export function initDiscord(onMessage, onCommand) {
         const guildId = interaction.guildId ?? null;
         const channelId = interaction.channelId;
         const sessionId = buildSessionIdFromContext(guildId, channelId, interaction.user.id);
+        const args = interaction.commandName === 'status'
+            ? ['status']
+            : interaction.commandName === 'channel-mode'
+                ? (() => {
+                    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 (!interaction.guildId)
+                        return null;
+                    const selectedPolicy = interaction.options
+                        .getString('policy', true)
+                        .trim()
+                        .toLowerCase();
+                    if (selectedPolicy !== 'open' &&
+                        selectedPolicy !== 'allowlist' &&
+                        selectedPolicy !== 'disabled')
+                        return null;
+                    return ['channel', 'policy', selectedPolicy];
+                })();
+        if (!args) {
+            await sendChunkedInteractionReply(interaction, 'This command can only be used in a server channel with a valid mode/policy option.');
+            return;
+        }
         try {
-            await commandHandler(sessionId, guildId, channelId, ['status'], async (text, files) => sendChunkedInteractionReply(interaction, text, files));
+            await commandHandler(sessionId, guildId, channelId, 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');
+            logger.error({ error, guildId, channelId, userId: interaction.user.id }, 'Discord slash command failed');
             await sendChunkedInteractionReply(interaction, formatError('Gateway Error', detail));
         }
     });
@@ -696,8 +1029,13 @@ export function initDiscord(onMessage, onCommand) {
         const channelId = msg.channelId;
         const userId = msg.author.id;
         const username = msg.author.username;
+        const behavior = sourceItem.behavior;
+        const startedAt = Date.now();
+        let releaseChannelSlot = null;
         const batchedContent = items.length > 1
-            ? items.map((item, index) => `Message ${index + 1}:\n${item.content}`).join('\n\n')
+            ? items
+                .map((item, index) => `Message ${index + 1}:\n${item.content}`)
+                .join('\n\n')
             : sourceItem.content;
         const channelInfoContext = buildChannelInfoContext(msg);
         const replyContext = await buildReplyContext(msg);
@@ -712,78 +1050,205 @@ export function initDiscord(onMessage, onCommand) {
         const participantContext = buildParticipantContext(items.map((item) => item.msg), inboundHistory.entries, rememberedParticipants);
         const mentionLookup = buildMentionLookup(items.map((item) => item.msg), inboundHistory.entries, rememberedParticipants);
         const combinedContent = `${feedbackNote ? `[Reaction feedback]\n${feedbackNote}\n\n` : ''}${channelInfoContext}${replyContext}${inboundHistory.context}${attachmentContext.context}${participantContext}${batchedContent}`;
+        const selectiveSilence = shouldSelectivelySilence({
+            sourceItem,
+            inboundHistory: inboundHistory.entries,
+            behavior,
+        });
         const abortController = new AbortController();
-        const typingLoop = startTypingLoop(msg);
+        const typingController = pending.typingController;
+        const lifecycleController = pending.lifecycleController;
+        const emitLifecyclePhase = (phase) => {
+            if (phase === 'queued') {
+                typingController.setPhase('received');
+            }
+            else if (phase === 'thinking') {
+                typingController.setPhase('thinking');
+            }
+            else if (phase === 'toolUse') {
+                typingController.setPhase('toolUse');
+            }
+            else if (phase === 'streaming') {
+                typingController.setPhase('streaming');
+            }
+            else {
+                typingController.setPhase('done');
+            }
+            lifecycleController?.setPhase(phase);
+        };
         const stream = new DiscordStreamManager(msg, {
-            onFirstMessage: () => typingLoop.stop(),
+            onFirstMessage: () => emitLifecyclePhase('streaming'),
+            humanDelay: behavior.humanDelay,
         });
         const inFlight = {
             abortController,
             stream,
             messageIds: new Set(items.map((item) => item.msg.id)),
             aborted: false,
+            emitLifecyclePhase,
         };
         for (const messageId of inFlight.messageIds) {
             inFlightByMessageId.set(messageId, inFlight);
         }
         try {
+            if (selectiveSilence) {
+                emitLifecyclePhase('done');
+                if (Math.random() < 0.5) {
+                    await withDiscordRetry('reaction-selective-silence', () => msg.react(pickReadWithoutReplyEmoji())).catch(() => { });
+                }
+                recordConversationMetric({
+                    durationMs: Date.now() - startedAt,
+                    ok: true,
+                });
+                return;
+            }
+            releaseChannelSlot = await waitForChannelConcurrencySlot(channelId, behavior.maxConcurrentPerChannel, abortController.signal);
+            if (abortController.signal.aborted) {
+                return;
+            }
             activeConversationRuns += 1;
-            updatePresence();
+            emitLifecyclePhase('thinking');
             await messageHandler(sessionId, guildId, channelId, userId, username, combinedContent, attachmentContext.media, async (text, files) => {
-                typingLoop.stop();
-                await sendChunkedReply(msg, text, files, mentionLookup);
+                emitLifecyclePhase('streaming');
+                await sendChunkedReply(msg, text, files, mentionLookup, behavior.humanDelay);
             }, {
                 sourceMessage: msg,
                 batchedMessages: items.map((item) => item.msg),
                 abortSignal: abortController.signal,
                 stream,
                 mentionLookup,
+                emitLifecyclePhase,
             });
+            emitLifecyclePhase('done');
+            recordConversationMetric({
+                durationMs: Date.now() - startedAt,
+                ok: true,
+            });
+            noteConversationExchange(sourceItem.cooldownKey);
         }
         catch (error) {
+            if (abortController.signal.aborted || inFlight.aborted) {
+                logger.debug({ channelId, sessionId }, 'Conversation batch aborted before completion');
+                return;
+            }
+            emitLifecyclePhase('error');
+            recordConversationMetric({
+                durationMs: Date.now() - startedAt,
+                ok: false,
+                error,
+            });
             logger.error({ error, channelId, sessionId }, 'Conversation batch handling failed');
             const detail = error instanceof Error ? error.message : String(error);
             if (stream.hasSentMessages()) {
                 await stream.fail(formatError('Gateway Error', detail));
             }
             else {
-                await sendChunkedReply(msg, formatError('Gateway Error', detail), undefined, mentionLookup);
+                await sendChunkedReply(msg, formatError('Gateway Error', detail), undefined, mentionLookup, behavior.humanDelay);
             }
         }
         finally {
             activeConversationRuns = Math.max(0, activeConversationRuns - 1);
-            updatePresence();
+            if (releaseChannelSlot) {
+                releaseChannelSlot();
+            }
             for (const messageId of inFlight.messageIds) {
                 if (inFlightByMessageId.get(messageId) === inFlight) {
                     inFlightByMessageId.delete(messageId);
                 }
             }
-            typingLoop.stop();
+            typingController.stop();
             await Promise.all(items.map(async (item) => {
-                await item.clearReaction();
+                await item.clearAckReaction();
             }));
         }
     };
-    const queueConversationMessage = async (msg, content) => {
+    const queueConversationMessage = async (msg, content, behavior) => {
         const key = `${msg.channelId}:${msg.author.id}`;
-        const clearReaction = await addProcessingReaction(msg);
-        const queued = { msg, content, clearReaction };
+        const cooldownKey = buildConversationCooldownKey(msg.channelId, msg.author.id);
+        const adjustedHumanDelay = resolveHumanDelayWithBehavior(behavior.humanDelay, cooldownKey);
+        const queuedBehavior = {
+            ...behavior,
+            humanDelay: adjustedHumanDelay,
+        };
+        const wasExplicitlyAddressed = !msg.guild ||
+            hasPrefixInvocation(msg.content || '') ||
+            Boolean(client.user && msg.mentions.has(client.user));
+        let clearAckReaction = async () => { };
+        if (client.user && shouldApplyAckReaction(msg, behavior)) {
+            const clearReaction = await addAckReaction({
+                message: msg,
+                emoji: behavior.ackReaction,
+                withRetry: withDiscordRetry,
+                botUserId: client.user.id,
+            });
+            clearAckReaction = behavior.removeAckAfterReply
+                ? clearReaction
+                : async () => { };
+        }
+        const queued = {
+            msg,
+            content,
+            behavior: queuedBehavior,
+            clearAckReaction,
+            wasExplicitlyAddressed,
+            cooldownKey,
+        };
         const existing = pendingBatches.get(key);
+        const shouldDebounceMessage = shouldDebounceInbound({
+            content: msg.content || '',
+            hasAttachments: msg.attachments.size > 0,
+            isPrefixedCommand: hasPrefixInvocation(msg.content || ''),
+        });
         if (!existing) {
+            const typingController = createTypingController(msg, behavior.typingMode);
+            typingController.setPhase('received');
+            const lifecycleController = client.user && DISCORD_LIFECYCLE_REACTIONS.enabled
+                ? new LifecycleReactionController({
+                    message: msg,
+                    withRetry: withDiscordRetry,
+                    botUserId: client.user.id,
+                    config: {
+                        enabled: DISCORD_LIFECYCLE_REACTIONS.enabled,
+                        removeOnComplete: DISCORD_LIFECYCLE_REACTIONS.removeOnComplete,
+                        phases: DISCORD_LIFECYCLE_REACTIONS.phases,
+                    },
+                })
+                : null;
+            lifecycleController?.setPhase('queued');
+            const baseDelayMs = shouldDebounceMessage ? behavior.debounceMs : 0;
+            const startupStaggerMs = startupConnectedAtMs > 0 &&
+                Date.now() - startupConnectedAtMs < STARTUP_STAGGER_WINDOW_MS &&
+                !wasExplicitlyAddressed
+                ? randomIntInRange(STARTUP_STAGGER_MIN_DELAY_MS, STARTUP_STAGGER_MAX_DELAY_MS)
+                : 0;
+            const delayMs = baseDelayMs + startupStaggerMs;
             const timer = setTimeout(() => {
                 void dispatchConversationBatch(key);
-            }, MESSAGE_DEBOUNCE_MS);
+            }, delayMs);
             pendingBatches.set(key, {
                 items: [queued],
                 timer,
+                typingController,
+                lifecycleController,
             });
             return;
         }
+        existing.typingController.setPhase('received');
+        existing.lifecycleController?.setPhase('queued');
         clearTimeout(existing.timer);
         existing.items.push(queued);
+        const shouldFlushImmediately = !shouldDebounceMessage ||
+            existing.items.length >= DEFAULT_DEBOUNCE_MAX_BUFFER;
+        const baseDelayMs = shouldFlushImmediately ? 0 : behavior.debounceMs;
+        const startupStaggerMs = startupConnectedAtMs > 0 &&
+            Date.now() - startupConnectedAtMs < STARTUP_STAGGER_WINDOW_MS &&
+            !wasExplicitlyAddressed
+            ? randomIntInRange(STARTUP_STAGGER_MIN_DELAY_MS, STARTUP_STAGGER_MAX_DELAY_MS)
+            : 0;
+        const delayMs = baseDelayMs + startupStaggerMs;
         existing.timer = setTimeout(() => {
             void dispatchConversationBatch(key);
-        }, MESSAGE_DEBOUNCE_MS);
+        }, delayMs);
     };
     const dropPendingMessage = async (messageId) => {
         for (const [key, pending] of pendingBatches) {
@@ -791,29 +1256,39 @@ export function initDiscord(onMessage, onCommand) {
             if (index === -1)
                 continue;
             const [removed] = pending.items.splice(index, 1);
-            await removed.clearReaction();
+            await removed.clearAckReaction();
             if (pending.items.length === 0) {
                 clearTimeout(pending.timer);
+                pending.typingController.stop();
+                await pending.lifecycleController?.clear();
                 pendingBatches.delete(key);
             }
             return;
         }
     };
-    const updatePendingMessage = async (messageId, nextMsg, nextContent) => {
+    const updatePendingMessage = async (messageId, nextMsg, nextContent, nextBehavior) => {
         for (const [key, pending] of pendingBatches) {
             const index = pending.items.findIndex((item) => item.msg.id === messageId);
             if (index === -1)
                 continue;
             if (!nextContent) {
                 const [removed] = pending.items.splice(index, 1);
-                await removed.clearReaction();
+                await removed.clearAckReaction();
             }
             else {
                 pending.items[index].msg = nextMsg;
                 pending.items[index].content = nextContent;
+                pending.items[index].behavior = nextBehavior;
+                pending.items[index].wasExplicitlyAddressed =
+                    !nextMsg.guild ||
+                        hasPrefixInvocation(nextMsg.content || '') ||
+                        Boolean(client.user && nextMsg.mentions.has(client.user));
+                pending.items[index].cooldownKey = buildConversationCooldownKey(nextMsg.channelId, nextMsg.author.id);
             }
             if (pending.items.length === 0) {
                 clearTimeout(pending.timer);
+                pending.typingController.stop();
+                await pending.lifecycleController?.clear();
                 pendingBatches.delete(key);
             }
             return true;
@@ -826,15 +1301,16 @@ export function initDiscord(onMessage, onCommand) {
         const sessionId = getSessionId(msg);
         const guildId = msg.guild?.id || null;
         const channelId = msg.channelId;
+        const behavior = resolveChannelBehavior(msg);
         const content = cleanIncomingContent(msg.content);
         observeMessageParticipants(msg, content);
         const immediateMentionLookup = buildMentionLookup([msg], [], msg.guild ? participantMemoryByChannel.get(msg.channelId) : undefined);
         const reply = async (text, files) => {
-            await sendChunkedReply(msg, text, files, immediateMentionLookup);
+            await sendChunkedReply(msg, text, files, immediateMentionLookup, behavior.humanDelay);
         };
         const commandReply = async (text, files) => {
             try {
-                await sendChunkedDirectReply(msg, text, files, immediateMentionLookup);
+                await sendChunkedDirectReply(msg, text, files, immediateMentionLookup, behavior.humanDelay);
             }
             catch (error) {
                 logger.warn({ error, userId: msg.author.id, channelId: msg.channelId }, 'Failed to send command reply via DM; command response dropped');
@@ -867,7 +1343,7 @@ export function initDiscord(onMessage, onCommand) {
             await commandHandler(sessionId, guildId, channelId, [parsed.command, ...parsed.args], commandReply);
             return;
         }
-        if (!isTrigger(msg))
+        if (!isTrigger(msg, behavior))
             return;
         if (ignorePrefixCommand) {
             return;
@@ -885,7 +1361,14 @@ export function initDiscord(onMessage, onCommand) {
             await reply('How can I help? Send me a message or try `!claw help`.');
             return;
         }
-        await queueConversationMessage(msg, content);
+        const readWithoutReplyHandled = await maybeHandleReadWithoutReply(msg, content);
+        if (readWithoutReplyHandled) {
+            return;
+        }
+        const rateLimitAllowed = await enforcePerUserRateLimit(msg, behavior);
+        if (!rateLimitAllowed)
+            return;
+        await queueConversationMessage(msg, content, behavior);
     });
     client.on('messageUpdate', async (_oldMsg, nextMsg) => {
         if (DISCORD_COMMANDS_ONLY)
@@ -898,15 +1381,19 @@ export function initDiscord(onMessage, onCommand) {
         if (fetched.author?.bot)
             return;
         const updatedContent = cleanIncomingContent(fetched.content || '');
+        const behavior = resolveChannelBehavior(fetched);
         observeMessageParticipants(fetched, updatedContent);
-        if (!isTrigger(fetched))
+        if (!isTrigger(fetched, behavior)) {
+            await updatePendingMessage(fetched.id, fetched, '', behavior);
             return;
-        await updatePendingMessage(fetched.id, fetched, updatedContent);
+        }
+        await updatePendingMessage(fetched.id, fetched, updatedContent, behavior);
         const inFlight = inFlightByMessageId.get(fetched.id);
         if (!inFlight || inFlight.aborted)
             return;
         inFlight.aborted = true;
         inFlight.abortController.abort();
+        inFlight.emitLifecyclePhase('error');
         for (const messageId of inFlight.messageIds) {
             if (inFlightByMessageId.get(messageId) === inFlight) {
                 inFlightByMessageId.delete(messageId);
@@ -914,7 +1401,10 @@ export function initDiscord(onMessage, onCommand) {
         }
         await inFlight.stream.discard();
         if (updatedContent) {
-            await queueConversationMessage(fetched, updatedContent);
+            const rateLimitAllowed = await enforcePerUserRateLimit(fetched, behavior);
+            if (!rateLimitAllowed)
+                return;
+            await queueConversationMessage(fetched, updatedContent, behavior);
         }
     });
     client.on('messageDelete', async (msg) => {
@@ -924,6 +1414,7 @@ export function initDiscord(onMessage, onCommand) {
             return;
         inFlight.aborted = true;
         inFlight.abortController.abort();
+        inFlight.emitLifecyclePhase('error');
         for (const messageId of inFlight.messageIds) {
             if (inFlightByMessageId.get(messageId) === inFlight) {
                 inFlightByMessageId.delete(messageId);
@@ -956,6 +1447,11 @@ export function initDiscord(onMessage, onCommand) {
     client.login(DISCORD_TOKEN);
     return client;
 }
+export async function setDiscordMaintenancePresence() {
+    if (!presenceController)
+        return;
+    await presenceController.setMaintenance();
+}
 /**
  * Send a message to a channel by ID (used by scheduler).
  */