@poolzin/pool-bot 2026.2.25 → 2026.2.26

package/dist/config/legacy.migrations.part-1.js

@@ -1,63 +1,71 @@
+import { resolveDiscordPreviewStreamMode, resolveSlackNativeStreaming, resolveSlackStreamingMode, resolveTelegramPreviewStreamMode, } from "./discord-preview-streaming.js";
 import { ensureRecord, getRecord, isRecord, mergeMissing, } from "./legacy.shared.js";
+function migrateBindings(raw, changes, changeNote, mutator) {
+    const bindings = Array.isArray(raw.bindings) ? raw.bindings : null;
+    if (!bindings) {
+        return;
+    }
+    let touched = false;
+    for (const entry of bindings) {
+        if (!isRecord(entry)) {
+            continue;
+        }
+        const match = getRecord(entry.match);
+        if (!match) {
+            continue;
+        }
+        if (!mutator(match)) {
+            continue;
+        }
+        entry.match = match;
+        touched = true;
+    }
+    if (touched) {
+        raw.bindings = bindings;
+        changes.push(changeNote);
+    }
+}
+function ensureDefaultGroupEntry(section) {
+    const groups = isRecord(section.groups) ? section.groups : {};
+    const defaultKey = "*";
+    const entry = isRecord(groups[defaultKey]) ? groups[defaultKey] : {};
+    return { groups, entry };
+}
 export const LEGACY_CONFIG_MIGRATIONS_PART_1 = [
     {
         id: "bindings.match.provider->bindings.match.channel",
         describe: "Move bindings[].match.provider to bindings[].match.channel",
         apply: (raw, changes) => {
-            const bindings = Array.isArray(raw.bindings) ? raw.bindings : null;
-            if (!bindings)
-                return;
-            let touched = false;
-            for (const entry of bindings) {
-                if (!isRecord(entry))
-                    continue;
-                const match = getRecord(entry.match);
-                if (!match)
-                    continue;
-                if (typeof match.channel === "string" && match.channel.trim())
-                    continue;
+            migrateBindings(raw, changes, "Moved bindings[].match.provider → bindings[].match.channel.", (match) => {
+                if (typeof match.channel === "string" && match.channel.trim()) {
+                    return false;
+                }
                 const provider = typeof match.provider === "string" ? match.provider.trim() : "";
-                if (!provider)
-                    continue;
+                if (!provider) {
+                    return false;
+                }
                 match.channel = provider;
                 delete match.provider;
-                entry.match = match;
-                touched = true;
-            }
-            if (touched) {
-                raw.bindings = bindings;
-                changes.push("Moved bindings[].match.provider → bindings[].match.channel.");
-            }
+                return true;
+            });
         },
     },
     {
         id: "bindings.match.accountID->bindings.match.accountId",
         describe: "Move bindings[].match.accountID to bindings[].match.accountId",
         apply: (raw, changes) => {
-            const bindings = Array.isArray(raw.bindings) ? raw.bindings : null;
-            if (!bindings)
-                return;
-            let touched = false;
-            for (const entry of bindings) {
-                if (!isRecord(entry))
-                    continue;
-                const match = getRecord(entry.match);
-                if (!match)
-                    continue;
-                if (match.accountId !== undefined)
-                    continue;
+            migrateBindings(raw, changes, "Moved bindings[].match.accountID → bindings[].match.accountId.", (match) => {
+                if (match.accountId !== undefined) {
+                    return false;
+                }
                 const accountID = typeof match.accountID === "string" ? match.accountID.trim() : match.accountID;
-                if (!accountID)
-                    continue;
+                if (!accountID) {
+                    return false;
+                }
                 match.accountId = accountID;
                 delete match.accountID;
-                entry.match = match;
-                touched = true;
-            }
-            if (touched) {
-                raw.bindings = bindings;
-                changes.push("Moved bindings[].match.accountID → bindings[].match.accountId.");
-            }
+                return true;
+            });
         },
     },
     {
@@ -65,26 +73,33 @@ export const LEGACY_CONFIG_MIGRATIONS_PART_1 = [
         describe: "Move session.sendPolicy.rules[].match.provider to match.channel",
         apply: (raw, changes) => {
             const session = getRecord(raw.session);
-            if (!session)
+            if (!session) {
                 return;
+            }
             const sendPolicy = getRecord(session.sendPolicy);
-            if (!sendPolicy)
+            if (!sendPolicy) {
                 return;
+            }
             const rules = Array.isArray(sendPolicy.rules) ? sendPolicy.rules : null;
-            if (!rules)
+            if (!rules) {
                 return;
+            }
             let touched = false;
             for (const rule of rules) {
-                if (!isRecord(rule))
+                if (!isRecord(rule)) {
                     continue;
+                }
                 const match = getRecord(rule.match);
-                if (!match)
+                if (!match) {
                     continue;
-                if (typeof match.channel === "string" && match.channel.trim())
+                }
+                if (typeof match.channel === "string" && match.channel.trim()) {
                     continue;
+                }
                 const provider = typeof match.provider === "string" ? match.provider.trim() : "";
-                if (!provider)
+                if (!provider) {
                     continue;
+                }
                 match.channel = provider;
                 delete match.provider;
                 rule.match = match;
@@ -103,13 +118,16 @@ export const LEGACY_CONFIG_MIGRATIONS_PART_1 = [
         describe: "Move messages.queue.byProvider to messages.queue.byChannel",
         apply: (raw, changes) => {
             const messages = getRecord(raw.messages);
-            if (!messages)
+            if (!messages) {
                 return;
+            }
             const queue = getRecord(messages.queue);
-            if (!queue)
+            if (!queue) {
                 return;
-            if (queue.byProvider === undefined)
+            }
+            if (queue.byProvider === undefined) {
                 return;
+            }
             if (queue.byChannel === undefined) {
                 queue.byChannel = queue.byProvider;
                 changes.push("Moved messages.queue.byProvider → messages.queue.byChannel.");
@@ -136,13 +154,15 @@ export const LEGACY_CONFIG_MIGRATIONS_PART_1 = [
                 "msteams",
             ];
             const legacyEntries = legacyKeys.filter((key) => isRecord(raw[key]));
-            if (legacyEntries.length === 0)
+            if (legacyEntries.length === 0) {
                 return;
+            }
             const channels = ensureRecord(raw, "channels");
             for (const key of legacyEntries) {
                 const legacy = getRecord(raw[key]);
-                if (!legacy)
+                if (!legacy) {
                     continue;
+                }
                 const channelEntry = ensureRecord(channels, key);
                 const hadEntries = Object.keys(channelEntry).length > 0;
                 mergeMissing(channelEntry, legacy);
@@ -153,16 +173,109 @@ export const LEGACY_CONFIG_MIGRATIONS_PART_1 = [
             raw.channels = channels;
         },
     },
+    {
+        id: "channels.streaming-keys->channels.streaming",
+        describe: "Normalize legacy streaming keys to channels.<provider>.streaming (Telegram/Discord/Slack)",
+        apply: (raw, changes) => {
+            const channels = getRecord(raw.channels);
+            if (!channels) {
+                return;
+            }
+            const migrateProviderEntry = (params) => {
+                const hasLegacyStreamMode = params.entry.streamMode !== undefined;
+                const legacyStreaming = params.entry.streaming;
+                const legacyNativeStreaming = params.entry.nativeStreaming;
+                if (params.provider === "telegram") {
+                    if (!hasLegacyStreamMode && typeof legacyStreaming !== "boolean") {
+                        return;
+                    }
+                    const resolved = resolveTelegramPreviewStreamMode(params.entry);
+                    params.entry.streaming = resolved;
+                    if (hasLegacyStreamMode) {
+                        delete params.entry.streamMode;
+                        changes.push(`Moved ${params.pathPrefix}.streamMode → ${params.pathPrefix}.streaming (${resolved}).`);
+                    }
+                    if (typeof legacyStreaming === "boolean") {
+                        changes.push(`Normalized ${params.pathPrefix}.streaming boolean → enum (${resolved}).`);
+                    }
+                    return;
+                }
+                if (params.provider === "discord") {
+                    if (!hasLegacyStreamMode && typeof legacyStreaming !== "boolean") {
+                        return;
+                    }
+                    const resolved = resolveDiscordPreviewStreamMode(params.entry);
+                    params.entry.streaming = resolved;
+                    if (hasLegacyStreamMode) {
+                        delete params.entry.streamMode;
+                        changes.push(`Moved ${params.pathPrefix}.streamMode → ${params.pathPrefix}.streaming (${resolved}).`);
+                    }
+                    if (typeof legacyStreaming === "boolean") {
+                        changes.push(`Normalized ${params.pathPrefix}.streaming boolean → enum (${resolved}).`);
+                    }
+                    return;
+                }
+                if (!hasLegacyStreamMode && typeof legacyStreaming !== "boolean") {
+                    return;
+                }
+                const resolvedStreaming = resolveSlackStreamingMode(params.entry);
+                const resolvedNativeStreaming = resolveSlackNativeStreaming(params.entry);
+                params.entry.streaming = resolvedStreaming;
+                params.entry.nativeStreaming = resolvedNativeStreaming;
+                if (hasLegacyStreamMode) {
+                    delete params.entry.streamMode;
+                    changes.push(`Moved ${params.pathPrefix}.streamMode → ${params.pathPrefix}.streaming (${resolvedStreaming}).`);
+                }
+                if (typeof legacyStreaming === "boolean") {
+                    changes.push(`Moved ${params.pathPrefix}.streaming (boolean) → ${params.pathPrefix}.nativeStreaming (${resolvedNativeStreaming}).`);
+                }
+                else if (typeof legacyNativeStreaming !== "boolean" && hasLegacyStreamMode) {
+                    changes.push(`Set ${params.pathPrefix}.nativeStreaming → ${resolvedNativeStreaming}.`);
+                }
+            };
+            const migrateProvider = (provider) => {
+                const providerEntry = getRecord(channels[provider]);
+                if (!providerEntry) {
+                    return;
+                }
+                migrateProviderEntry({
+                    provider,
+                    entry: providerEntry,
+                    pathPrefix: `channels.${provider}`,
+                });
+                const accounts = getRecord(providerEntry.accounts);
+                if (!accounts) {
+                    return;
+                }
+                for (const [accountId, accountValue] of Object.entries(accounts)) {
+                    const account = getRecord(accountValue);
+                    if (!account) {
+                        continue;
+                    }
+                    migrateProviderEntry({
+                        provider,
+                        entry: account,
+                        pathPrefix: `channels.${provider}.accounts.${accountId}`,
+                    });
+                }
+            };
+            migrateProvider("telegram");
+            migrateProvider("discord");
+            migrateProvider("slack");
+        },
+    },
     {
         id: "routing.allowFrom->channels.whatsapp.allowFrom",
         describe: "Move routing.allowFrom to channels.whatsapp.allowFrom",
         apply: (raw, changes) => {
             const routing = raw.routing;
-            if (!routing || typeof routing !== "object")
+            if (!routing || typeof routing !== "object") {
                 return;
+            }
             const allowFrom = routing.allowFrom;
-            if (allowFrom === undefined)
+            if (allowFrom === undefined) {
                 return;
+            }
             const channels = getRecord(raw.channels);
             const whatsapp = channels ? getRecord(channels.whatsapp) : null;
             if (!whatsapp) {
@@ -193,31 +306,30 @@ export const LEGACY_CONFIG_MIGRATIONS_PART_1 = [
         describe: "Move routing.groupChat.requireMention to channels.whatsapp/telegram/imessage groups",
         apply: (raw, changes) => {
             const routing = raw.routing;
-            if (!routing || typeof routing !== "object")
+            if (!routing || typeof routing !== "object") {
                 return;
+            }
             const groupChat = routing.groupChat &&
                 typeof routing.groupChat === "object"
                 ? routing.groupChat
                 : null;
-            if (!groupChat)
+            if (!groupChat) {
                 return;
+            }
             const requireMention = groupChat.requireMention;
-            if (requireMention === undefined)
+            if (requireMention === undefined) {
                 return;
+            }
             const channels = ensureRecord(raw, "channels");
             const applyTo = (key, options) => {
-                if (options?.requireExisting && !isRecord(channels[key]))
+                if (options?.requireExisting && !isRecord(channels[key])) {
                     return;
+                }
                 const section = channels[key] && typeof channels[key] === "object"
                     ? channels[key]
                     : {};
-                const groups = section.groups && typeof section.groups === "object"
-                    ? section.groups
-                    : {};
+                const { groups, entry } = ensureDefaultGroupEntry(section);
                 const defaultKey = "*";
-                const entry = groups[defaultKey] && typeof groups[defaultKey] === "object"
-                    ? groups[defaultKey]
-                    : {};
                 if (entry.requireMention === undefined) {
                     entry.requireMention = requireMention;
                     groups[defaultKey] = entry;
@@ -247,19 +359,22 @@ export const LEGACY_CONFIG_MIGRATIONS_PART_1 = [
         describe: "Move gateway.token to gateway.auth.token",
         apply: (raw, changes) => {
             const gateway = raw.gateway;
-            if (!gateway || typeof gateway !== "object")
+            if (!gateway || typeof gateway !== "object") {
                 return;
+            }
             const token = gateway.token;
-            if (token === undefined)
+            if (token === undefined) {
                 return;
+            }
             const gatewayObj = gateway;
             const auth = gatewayObj.auth && typeof gatewayObj.auth === "object"
                 ? gatewayObj.auth
                 : {};
             if (auth.token === undefined) {
                 auth.token = token;
-                if (!auth.mode)
+                if (!auth.mode) {
                     auth.mode = "token";
+                }
                 changes.push("Moved gateway.token → gateway.auth.token.");
             }
             else {
@@ -278,19 +393,15 @@ export const LEGACY_CONFIG_MIGRATIONS_PART_1 = [
         apply: (raw, changes) => {
             const channels = ensureRecord(raw, "channels");
             const telegram = channels.telegram;
-            if (!telegram || typeof telegram !== "object")
+            if (!telegram || typeof telegram !== "object") {
                 return;
+            }
             const requireMention = telegram.requireMention;
-            if (requireMention === undefined)
+            if (requireMention === undefined) {
                 return;
-            const groups = telegram.groups &&
-                typeof telegram.groups === "object"
-                ? telegram.groups
-                : {};
+            }
+            const { groups, entry } = ensureDefaultGroupEntry(telegram);
             const defaultKey = "*";
-            const entry = groups[defaultKey] && typeof groups[defaultKey] === "object"
-                ? groups[defaultKey]
-                : {};
             if (entry.requireMention === undefined) {
                 entry.requireMention = requireMention;
                 groups[defaultKey] = entry;

package/dist/config/legacy.shared.js

@@ -1,3 +1,4 @@
+import { isBlockedObjectKey } from "./prototype-keys.js";
 export const isRecord = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
 export const getRecord = (value) => isRecord(value) ? value : null;
 export const ensureRecord = (root, key) => {
@@ -10,8 +11,9 @@ export const ensureRecord = (root, key) => {
 };
 export const mergeMissing = (target, source) => {
     for (const [key, value] of Object.entries(source)) {
-        if (value === undefined)
+        if (value === undefined || isBlockedObjectKey(key)) {
             continue;
+        }
         const existing = target[key];
         if (existing === undefined) {
             target[key] = value;

package/dist/config/merge-patch.js

@@ -1,4 +1,5 @@
 import { isPlainObject } from "../utils.js";
+import { isBlockedObjectKey } from "./prototype-keys.js";
 function isObjectWithStringId(value) {
     if (!isPlainObject(value)) {
         return false;
@@ -46,6 +47,9 @@ export function applyMergePatch(base, patch, options = {}) {
     }
     const result = isPlainObject(base) ? { ...base } : {};
     for (const [key, value] of Object.entries(patch)) {
+        if (isBlockedObjectKey(key)) {
+            continue;
+        }
         if (value === null) {
             delete result[key];
             continue;

package/dist/config/prototype-keys.js

@@ -0,0 +1,4 @@
+const BLOCKED_OBJECT_KEYS = new Set(["__proto__", "prototype", "constructor"]);
+export function isBlockedObjectKey(key) {
+    return BLOCKED_OBJECT_KEYS.has(key);
+}

package/dist/config/schema.help.js

@@ -16,10 +16,14 @@ export const FIELD_HELP = {
     "discovery.mdns.mode": 'mDNS broadcast mode ("minimal" default, "full" includes cliPath/sshPort, "off" disables mDNS).',
     "gateway.auth.token": "Required by default for gateway access (unless using Tailscale Serve identity); required for non-loopback binds.",
     "gateway.auth.password": "Required for Tailscale funnel.",
+    "agents.defaults.sandbox.browser.network": "Docker network for sandbox browser containers (default: poolbot-sandbox-browser). Avoid bridge if you need stricter isolation.",
+    "agents.list[].sandbox.browser.network": "Per-agent override for sandbox browser Docker network.",
+    "agents.defaults.sandbox.browser.cdpSourceRange": "Optional CIDR allowlist for container-edge CDP ingress (for example 172.21.0.1/32).",
+    "agents.list[].sandbox.browser.cdpSourceRange": "Per-agent override for CDP source CIDR allowlist.",
     "gateway.controlUi.basePath": "Optional URL prefix where the Control UI is served (e.g. /poolbot).",
     "gateway.controlUi.root": "Optional filesystem root for Control UI assets (defaults to dist/control-ui).",
     "gateway.controlUi.allowedOrigins": "Allowed browser origins for Control UI/WebChat websocket connections (full origins only, e.g. https://control.example.com).",
-    "gateway.controlUi.allowInsecureAuth": "Allow Control UI auth over insecure HTTP (token-only; not recommended).",
+    "gateway.controlUi.allowInsecureAuth": "Insecure-auth toggle; Control UI still enforces secure context + device identity unless dangerouslyDisableDeviceAuth is enabled.",
     "gateway.controlUi.dangerouslyDisableDeviceAuth": "DANGEROUS. Disable Control UI device identity checks (token/password only).",
     "gateway.http.endpoints.chatCompletions.enabled": "Enable the OpenAI-compatible `POST /v1/chat/completions` endpoint (default: false).",
     "gateway.reload.mode": 'Hot reload strategy for config changes ("hybrid" recommended).',
@@ -127,11 +131,19 @@ export const FIELD_HELP = {
     "agents.defaults.memorySearch.query.hybrid.vectorWeight": "Weight for vector similarity when merging results (0-1).",
     "agents.defaults.memorySearch.query.hybrid.textWeight": "Weight for BM25 text relevance when merging results (0-1).",
     "agents.defaults.memorySearch.query.hybrid.candidateMultiplier": "Multiplier for candidate pool size (default: 4).",
+    "agents.defaults.memorySearch.query.hybrid.mmr.enabled": "Enable MMR re-ranking to reduce near-duplicate memory hits (default: false).",
+    "agents.defaults.memorySearch.query.hybrid.mmr.lambda": "MMR relevance/diversity balance (0 = max diversity, 1 = max relevance, default: 0.7).",
+    "agents.defaults.memorySearch.query.hybrid.temporalDecay.enabled": "Enable exponential recency decay for hybrid scoring (default: false).",
+    "agents.defaults.memorySearch.query.hybrid.temporalDecay.halfLifeDays": "Half-life in days for temporal decay (default: 30).",
     "agents.defaults.memorySearch.cache.enabled": "Cache chunk embeddings in SQLite to speed up reindexing and frequent updates (default: true).",
     memory: "Memory backend configuration (global).",
     "memory.backend": 'Memory backend ("builtin" for Pool Bot embeddings, "qmd" for QMD sidecar).',
     "memory.citations": 'Default citation behavior ("auto", "on", or "off").',
     "memory.qmd.command": "Path to the qmd binary (default: resolves from PATH).",
+    "memory.qmd.mcporter": "Optional: route QMD searches through mcporter (MCP runtime) instead of spawning `qmd` per query. Intended to avoid per-search cold starts when QMD models are large.",
+    "memory.qmd.mcporter.enabled": "Enable mcporter-backed QMD searches (default: false).",
+    "memory.qmd.mcporter.serverName": "mcporter server name to call (default: qmd). Server should run `qmd mcp` with lifecycle keep-alive.",
+    "memory.qmd.mcporter.startDaemon": "Start `mcporter daemon start` automatically when enabled (default: true).",
     "memory.qmd.includeDefaultMemory": "Whether to automatically index MEMORY.md + memory/**/*.md (default: true).",
     "memory.qmd.paths": "Additional directories/files to index with QMD (path + optional glob pattern).",
     "memory.qmd.paths.path": "Absolute or ~-relative path to index via QMD.",
@@ -173,6 +185,12 @@ export const FIELD_HELP = {
     "plugins.installs.*.sourcePath": "Original archive/path used for install (if any).",
     "plugins.installs.*.installPath": "Resolved install directory (usually ~/.poolbot/extensions/<id>).",
     "plugins.installs.*.version": "Version recorded at install time (if available).",
+    "plugins.installs.*.resolvedName": "Resolved npm package name from the fetched artifact.",
+    "plugins.installs.*.resolvedVersion": "Resolved npm package version from the fetched artifact (useful for non-pinned specs).",
+    "plugins.installs.*.resolvedSpec": "Resolved exact npm spec (<name>@<version>) from the fetched artifact.",
+    "plugins.installs.*.integrity": "Resolved npm dist integrity hash for the fetched artifact (if reported by npm).",
+    "plugins.installs.*.shasum": "Resolved npm dist shasum for the fetched artifact (if reported by npm).",
+    "plugins.installs.*.resolvedAt": "ISO timestamp when npm package metadata was last resolved for this install record.",
     "plugins.installs.*.installedAt": "ISO timestamp of last install/update.",
     "agents.list.*.identity.avatar": "Agent avatar (workspace-relative path, http(s) URL, or data URI).",
     "agents.defaults.model.primary": "Primary model (provider/model).",
@@ -191,11 +209,15 @@ export const FIELD_HELP = {
     "commands.bashForegroundMs": "How long bash waits before backgrounding (default: 2000; 0 backgrounds immediately).",
     "commands.config": "Allow /config chat command to read/write config on disk (default: false).",
     "commands.debug": "Allow /debug chat command for runtime-only overrides (default: false).",
-    "commands.restart": "Allow /restart and gateway restart tool actions (default: false).",
+    "commands.restart": "Allow /restart and gateway restart tool actions (default: true).",
     "commands.useAccessGroups": "Enforce access-group allowlists/policies for commands.",
     "commands.ownerAllowFrom": "Explicit owner allowlist for owner-only tools/commands. Use channel-native IDs (optionally prefixed like \"whatsapp:+15551234567\"). '*' is ignored.",
+    "commands.ownerDisplay": "Controls how owner IDs are rendered in the system prompt. Allowed values: raw, hash. Default: raw.",
+    "commands.ownerDisplaySecret": "Optional secret used to HMAC hash owner IDs when ownerDisplay=hash. Prefer env substitution.",
     "session.dmScope": 'DM session scoping: "main" keeps continuity; "per-peer", "per-channel-peer", or "per-account-channel-peer" isolates DM history (recommended for shared inboxes/multi-account).',
     "session.identityLinks": "Map canonical identities to provider-prefixed peer IDs for DM session linking (example: telegram:123456).",
+    "session.threadBindings.enabled": "Global master switch for thread-bound session routing features. Channel/provider keys (for example channels.discord.threadBindings.enabled) override this default. Default: true.",
+    "session.threadBindings.ttlHours": "Default auto-unfocus TTL in hours for thread-bound sessions across providers/channels. Set 0 to disable (default: 24). Provider keys (for example channels.discord.threadBindings.ttlHours) override this.",
     "channels.telegram.configWrites": "Allow Telegram to write config in response to channel events/commands (default: true).",
     "channels.slack.configWrites": "Allow Slack to write config in response to channel events/commands (default: true).",
     "channels.mattermost.configWrites": "Allow Mattermost to write config in response to channel events/commands (default: true).",
@@ -205,6 +227,7 @@ export const FIELD_HELP = {
     "channels.signal.configWrites": "Allow Signal to write config in response to channel events/commands (default: true).",
     "channels.imessage.configWrites": "Allow iMessage to write config in response to channel events/commands (default: true).",
     "channels.msteams.configWrites": "Allow Microsoft Teams to write config in response to channel events/commands (default: true).",
+    "channels.modelByChannel": "Map provider -> channel id -> model override (values are provider/model or aliases).",
     ...IRC_FIELD_HELP,
     "channels.discord.commands.native": 'Override native commands for Discord (bool or "auto").',
     "channels.discord.commands.nativeSkills": 'Override native skill commands for Discord (bool or "auto").',
@@ -212,18 +235,26 @@ export const FIELD_HELP = {
     "channels.telegram.commands.nativeSkills": 'Override native skill commands for Telegram (bool or "auto").',
     "channels.slack.commands.native": 'Override native commands for Slack (bool or "auto").',
     "channels.slack.commands.nativeSkills": 'Override native skill commands for Slack (bool or "auto").',
-    "channels.slack.streamMode": "Live stream preview mode for Slack replies (replace | status_final | append).",
+    "channels.slack.streaming": 'Unified Slack stream preview mode: "off" | "partial" | "block" | "progress". Legacy boolean/streamMode keys are auto-mapped.',
+    "channels.slack.nativeStreaming": "Enable native Slack text streaming (chat.startStream/chat.appendStream/chat.stopStream) when channels.slack.streaming is partial (default: true).",
+    "channels.slack.streamMode": "Legacy Slack preview mode alias (replace | status_final | append); auto-migrated to channels.slack.streaming.",
     "session.agentToAgent.maxPingPongTurns": "Max reply-back turns between requester and target (0–5).",
     "channels.telegram.customCommands": "Additional Telegram bot menu commands (merged with native; conflicts ignored).",
     "messages.suppressToolErrors": "When true, suppress ⚠️ tool-error warnings from being shown to the user. The agent already sees errors in context and can retry. Default: false.",
     "messages.ackReaction": "Emoji reaction used to acknowledge inbound messages (empty disables).",
     "messages.ackReactionScope": 'When to send ack reactions ("group-mentions", "group-all", "direct", "all").',
+    "messages.statusReactions": "Lifecycle status reactions that update the emoji on the trigger message as the agent progresses (queued → thinking → tool → done/error).",
+    "messages.statusReactions.enabled": "Enable lifecycle status reactions for Telegram. When enabled, the ack reaction becomes the initial 'queued' state and progresses through thinking, tool, done/error automatically. Default: false.",
+    "messages.statusReactions.emojis": "Override default status reaction emojis. Keys: thinking, tool, coding, web, done, error, stallSoft, stallHard. Must be valid Telegram reaction emojis.",
+    "messages.statusReactions.timing": "Override default timing. Keys: debounceMs (700), stallSoftMs (25000), stallHardMs (60000), doneHoldMs (1500), errorHoldMs (2500).",
     "messages.inbound.debounceMs": "Debounce window (ms) for batching rapid inbound messages from the same sender (0 to disable).",
     "channels.telegram.dmPolicy": 'Direct message access control ("pairing" recommended). "open" requires channels.telegram.allowFrom=["*"].',
-    "channels.telegram.streamMode": "Live stream preview mode for Telegram replies (off | partial | block). Separate from block streaming; uses sendMessage + editMessageText.",
-    "channels.telegram.draftChunk.minChars": 'Minimum chars before emitting a Telegram stream preview update when channels.telegram.streamMode="block" (default: 200).',
-    "channels.telegram.draftChunk.maxChars": 'Target max size for a Telegram stream preview chunk when channels.telegram.streamMode="block" (default: 800; clamped to channels.telegram.textChunkLimit).',
-    "channels.telegram.draftChunk.breakPreference": "Preferred breakpoints for Telegram draft chunks (paragraph | newline | sentence). Default: paragraph.",
+    "channels.telegram.streaming": 'Unified Telegram stream preview mode: "off" | "partial" | "block" | "progress". "progress" maps to "partial" on Telegram. Legacy boolean/streamMode keys are auto-mapped.',
+    "channels.discord.streaming": 'Unified Discord stream preview mode: "off" | "partial" | "block" | "progress". "progress" maps to "partial" on Discord. Legacy boolean/streamMode keys are auto-mapped.',
+    "channels.discord.streamMode": "Legacy Discord preview mode alias (off | partial | block); auto-migrated to channels.discord.streaming.",
+    "channels.discord.draftChunk.minChars": 'Minimum chars before emitting a Discord stream preview update when channels.discord.streaming="block" (default: 200).',
+    "channels.discord.draftChunk.maxChars": 'Target max size for a Discord stream preview chunk when channels.discord.streaming="block" (default: 800; clamped to channels.discord.textChunkLimit).',
+    "channels.discord.draftChunk.breakPreference": "Preferred breakpoints for Discord draft chunks (paragraph | newline | sentence). Default: paragraph.",
     "channels.telegram.retry.attempts": "Max retry attempts for outbound Telegram API calls (default: 3).",
     "channels.telegram.retry.minDelayMs": "Minimum retry delay in ms for Telegram outbound calls.",
     "channels.telegram.retry.maxDelayMs": "Maximum retry delay cap in ms for Telegram outbound calls.",
@@ -243,7 +274,13 @@ export const FIELD_HELP = {
     "channels.discord.retry.maxDelayMs": "Maximum retry delay cap in ms for Discord outbound calls.",
     "channels.discord.retry.jitter": "Jitter factor (0-1) applied to Discord retry delays.",
     "channels.discord.maxLinesPerMessage": "Soft max line count per Discord message (default: 17).",
+    "channels.discord.threadBindings.enabled": "Enable Discord thread binding features (/focus, bound-thread routing/delivery, and thread-bound subagent sessions). Overrides session.threadBindings.enabled when set.",
+    "channels.discord.threadBindings.ttlHours": "Auto-unfocus TTL in hours for Discord thread-bound sessions (/focus and spawned thread sessions). Set 0 to disable (default: 24). Overrides session.threadBindings.ttlHours when set.",
+    "channels.discord.threadBindings.spawnSubagentSessions": "Allow subagent spawns with thread=true to auto-create and bind Discord threads (default: false; opt-in). Set true to enable thread-bound subagent spawns for this account/channel.",
     "channels.discord.ui.components.accentColor": "Accent color for Discord component containers (hex). Set per account via channels.discord.accounts.<id>.ui.components.accentColor.",
+    "channels.discord.voice.enabled": "Enable Discord voice channel conversations (default: true). Omit channels.discord.voice to keep voice support disabled for the account.",
+    "channels.discord.voice.autoJoin": "Voice channels to auto-join on startup (list of guildId/channelId entries).",
+    "channels.discord.voice.tts": "Optional TTS overrides for Discord voice playback (merged with messages.tts).",
     "channels.discord.intents.presence": "Enable the Guild Presences privileged intent. Must also be enabled in the Discord Developer Portal. Allows tracking user activities (e.g. Spotify). Default: false.",
     "channels.discord.intents.guildMembers": "Enable the Guild Members privileged intent. Must also be enabled in the Discord Developer Portal. Default: false.",
     "channels.discord.pluralkit.enabled": "Resolve PluralKit proxied messages and treat system members as distinct senders.",