@hybridaione/hybridclaw 0.2.3 → 0.2.7

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_ALLOWED_USER_IDS, DISCORD_COMMAND_MODE, 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 { 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 { 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 { createDiscordToolActionRunner, } from './tool-actions.js';
+import { buildSessionIdFromContext as buildSessionIdFromContextInbound, cleanIncomingContent as cleanIncomingContentInbound, hasLooseBotMention as hasLooseBotMentionInbound, hasPrefixInvocation as hasPrefixInvocationInbound, hasSlashCommandInvocation as hasSlashCommandInvocationInbound, isAddressedToChannel as isAddressedToChannelInbound, isAuthorizedCommandUser as isAuthorizedCommandUserInbound, isTrigger as isTriggerInbound, parseCommand as parseCommandInbound, shouldReplyInFreeMode as shouldReplyInFreeModeInbound, shouldSkipFreeReplyBecauseOtherUsersMentioned as shouldSkipFreeReplyBecauseOtherUsersMentionedInbound, } from './inbound.js';
+import { addMentionAlias, extractMentionAliasHints, normalizeMentionAlias, } from './mentions.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,
             });
         }
@@ -305,38 +343,150 @@ function getSessionId(msg) {
 function hasPrefixInvocation(content) {
     return hasPrefixInvocationInbound(content, botMentionRegex, DISCORD_PREFIX);
 }
+function hasSlashCommandInvocation(content) {
+    return hasSlashCommandInvocationInbound(content, botMentionRegex);
+}
 function isAuthorizedCommandUserId(userId) {
-    const configuredUserId = DISCORD_COMMAND_USER_ID.trim();
-    if (!configuredUserId)
-        return true;
-    return userId === configuredUserId;
+    return isAuthorizedCommandUserInbound({
+        mode: DISCORD_COMMAND_MODE,
+        userId,
+        allowedUserIds: DISCORD_COMMAND_ALLOWED_USER_IDS,
+        legacyCommandUserId: DISCORD_COMMAND_USER_ID,
+    });
 }
 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 shouldHandleFreeModeMessage(msg, behavior, content) {
+    if (!msg.guild)
+        return true;
+    const hasPrefixedInvocation = hasPrefixInvocation(msg.content || '');
+    const hasBotMention = Boolean(client.user && msg.mentions.has(client.user));
+    const hasLooseBotMention = client.user != null
+        ? hasLooseBotMentionInbound(content, [
+            client.user.username,
+            client.user.globalName || '',
+            msg.guild?.members.me?.displayName || '',
+        ])
+        : false;
+    const isReplyToBot = Boolean(client.user && msg.mentions.repliedUser?.id === client.user.id);
+    const mentionedUserIds = Array.from(msg.mentions.users.keys());
+    const botUserId = client.user?.id ?? null;
+    if (shouldSkipFreeReplyBecauseOtherUsersMentionedInbound({
+        guildMessageMode: behavior.guildMessageMode,
+        hasBotMention,
+        hasPrefixInvocation: hasPrefixedInvocation,
+        botUserId,
+        mentionedUserIds,
+    })) {
+        return false;
+    }
+    return shouldReplyInFreeModeInbound({
+        guildMessageMode: behavior.guildMessageMode,
+        content,
+        hasBotMention,
+        hasLooseBotMention,
+        isAddressedToChannel: isAddressedToChannelInbound(content),
+        hasPrefixInvocation: hasPrefixedInvocation,
+        isReplyToBot,
+        hasAttachments: msg.attachments.size > 0,
     });
 }
+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 +500,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 +537,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 +548,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 +582,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 +610,216 @@ 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)',
+            dmPermission: true,
+        },
+        {
+            name: 'approve',
+            description: 'View/respond to pending tool approval requests (private)',
+            dmPermission: true,
+            options: [
+                {
+                    type: ApplicationCommandOptionType.String,
+                    name: 'action',
+                    description: 'Action to perform',
+                    required: false,
+                    choices: [
+                        { name: 'view', value: 'view' },
+                        { name: 'yes', value: 'yes' },
+                        { name: 'session', value: 'session' },
+                        { name: 'agent', value: 'agent' },
+                        { name: 'no', value: 'no' },
+                    ],
+                },
+                {
+                    type: ApplicationCommandOptionType.String,
+                    name: 'approval_id',
+                    description: 'Optional approval id (defaults to latest pending)',
+                    required: false,
+                },
+            ],
+        },
+        {
+            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;
+    const globalDefinitions = definitions.filter((definition) => definition.name === 'status' || definition.name === 'approve');
+    try {
+        for (const definition of globalDefinitions) {
+            // POST is an upsert by name for global commands. Keep command IDs stable
+            // to avoid stale-client command references in DMs.
+            await client.application.commands.create(definition);
+            logger.info({ scope: 'global', command: definition.name }, 'Upserted slash command');
+        }
+    }
+    catch (error) {
+        logger.warn({ error }, 'Failed to register global slash commands');
+    }
     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 +894,103 @@ 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.guild)
+            return false;
+        if (msg.attachments.size > 0)
+            return false;
+        if (hasPrefixInvocation(msg.content || ''))
+            return false;
+        if (hasSlashCommandInvocation(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 +1004,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,30 +1027,91 @@ 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 !== 'approve' &&
+            interaction.commandName !== 'channel-mode' &&
+            interaction.commandName !== 'channel-policy') {
             return;
-        if (!isAuthorizedCommandUserId(interaction.user.id)) {
+        }
+        if (interaction.guildId &&
+            !isAuthorizedCommandUserId(interaction.user.id)) {
             await sendChunkedInteractionReply(interaction, 'You are not authorized to run commands for this bot.');
             return;
         }
         const guildId = interaction.guildId ?? null;
         const channelId = interaction.channelId;
         const sessionId = buildSessionIdFromContext(guildId, channelId, interaction.user.id);
+        const args = (() => {
+            if (interaction.commandName === 'status')
+                return ['status'];
+            if (interaction.commandName === 'approve') {
+                const action = interaction.options
+                    .getString('action', false)
+                    ?.trim()
+                    .toLowerCase() || 'view';
+                if (action !== 'view' &&
+                    action !== 'yes' &&
+                    action !== 'session' &&
+                    action !== 'agent' &&
+                    action !== 'no') {
+                    return null;
+                }
+                const approvalId = interaction.options.getString('approval_id', false)?.trim() || '';
+                return approvalId
+                    ? ['approve', action, approvalId]
+                    : ['approve', action];
+            }
+            if (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, interaction.user.id, interaction.user.username, 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 +1130,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 +1151,206 @@ 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)) ||
+            Boolean(client.user && msg.mentions.repliedUser?.id === client.user.id);
+        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 +1358,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,35 +1403,32 @@ 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');
             }
         };
         const parsed = parseCommand(msg.content);
-        const prefixedToken = hasPrefixInvocation(msg.content)
-            ? cleanIncomingContent(msg.content).split(/\s+/)[0]?.toLowerCase() || ''
-            : '';
-        const ignorePrefixCommand = prefixedToken === 'status';
+        const hasPrefixedInvocation = hasPrefixInvocation(msg.content);
+        const hasSlashInvocation = hasSlashCommandInvocation(msg.content);
+        const hasCommandInvocation = hasPrefixedInvocation || hasSlashInvocation;
         if (DISCORD_COMMANDS_ONLY) {
-            if (!hasPrefixInvocation(msg.content))
+            if (!hasCommandInvocation)
                 return;
-            if (!isAuthorizedCommandUserId(msg.author.id)) {
+            if (msg.guild && !isAuthorizedCommandUserId(msg.author.id)) {
                 logger.debug({ userId: msg.author.id, channelId: msg.channelId }, 'Ignoring unauthorized Discord command in commands-only mode');
                 return;
             }
-            if (ignorePrefixCommand) {
-                return;
-            }
             if (!parsed.isCommand) {
                 if (!content) {
                     await commandReply(`How can I help? Try \`${DISCORD_PREFIX} help\`.`);
@@ -864,28 +1438,37 @@ export function initDiscord(onMessage, onCommand) {
                 }
                 return;
             }
-            await commandHandler(sessionId, guildId, channelId, [parsed.command, ...parsed.args], commandReply);
+            await commandHandler(sessionId, guildId, channelId, msg.author.id, msg.author.username, [parsed.command, ...parsed.args], commandReply);
             return;
         }
-        if (!isTrigger(msg))
+        if (msg.guild &&
+            hasCommandInvocation &&
+            !isAuthorizedCommandUserId(msg.author.id)) {
+            logger.debug({ userId: msg.author.id, channelId: msg.channelId }, 'Ignoring unauthorized Discord prefixed command');
             return;
-        if (ignorePrefixCommand) {
+        }
+        if (!isTrigger(msg, behavior))
+            return;
+        if (parsed.isCommand && hasCommandInvocation) {
+            await commandHandler(sessionId, guildId, channelId, msg.author.id, msg.author.username, [parsed.command, ...parsed.args], commandReply);
             return;
         }
-        if (parsed.isCommand && hasPrefixInvocation(msg.content)) {
-            if (!isAuthorizedCommandUserId(msg.author.id)) {
-                logger.debug({ userId: msg.author.id, channelId: msg.channelId }, 'Ignoring unauthorized Discord command; processing as normal chat message');
-            }
-            else {
-                await commandHandler(sessionId, guildId, channelId, [parsed.command, ...parsed.args], commandReply);
-                return;
-            }
+        if (!shouldHandleFreeModeMessage(msg, behavior, content)) {
+            logger.debug({ channelId: msg.channelId, messageId: msg.id, userId: msg.author.id }, 'Skipping Discord free-mode message by relevance/mention gate');
+            return;
         }
         if (!content) {
             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 +1481,28 @@ 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;
+        }
+        if (hasPrefixInvocation(fetched.content || '') &&
+            !isAuthorizedCommandUserId(fetched.author.id)) {
+            await updatePendingMessage(fetched.id, fetched, '', behavior);
+            return;
+        }
+        if (!shouldHandleFreeModeMessage(fetched, behavior, updatedContent)) {
+            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 +1510,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 +1523,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 +1556,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).
  */