@poolzin/pool-bot 2026.2.24 → 2026.2.26

package/dist/auto-reply/reply/commands-tts.js

@@ -2,13 +2,16 @@ import { logVerbose } from "../../globals.js";
 import { getLastTtsAttempt, getTtsMaxLength, getTtsProvider, isSummarizationEnabled, isTtsEnabled, isTtsProviderConfigured, resolveTtsApiKey, resolveTtsConfig, resolveTtsPrefsPath, setLastTtsAttempt, setSummarizationEnabled, setTtsEnabled, setTtsMaxLength, setTtsProvider, textToSpeech, } from "../../tts/tts.js";
 function parseTtsCommand(normalized) {
     // Accept `/tts` and `/tts <action> [args]` as a single control surface.
-    if (normalized === "/tts")
+    if (normalized === "/tts") {
         return { action: "status", args: "" };
-    if (!normalized.startsWith("/tts "))
+    }
+    if (!normalized.startsWith("/tts ")) {
         return null;
+    }
     const rest = normalized.slice(5).trim();
-    if (!rest)
+    if (!rest) {
         return { action: "status", args: "" };
+    }
     const [action, ...tail] = rest.split(/\s+/);
     return { action: action.toLowerCase(), args: tail.join(" ").trim() };
 }
@@ -39,11 +42,13 @@ function ttsUsage() {
     };
 }
 export const handleTtsCommands = async (params, allowTextCommands) => {
-    if (!allowTextCommands)
+    if (!allowTextCommands) {
         return null;
+    }
     const parsed = parseTtsCommand(params.command.commandBodyNormalized);
-    if (!parsed)
+    if (!parsed) {
         return null;
+    }
     if (!params.command.isAuthorizedSender) {
         logVerbose(`Ignoring TTS command from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
         return { shouldContinue: false };

package/dist/auto-reply/reply/config-value.js

@@ -1,7 +1,8 @@
 export function parseConfigValue(raw) {
     const trimmed = raw.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return { error: "Missing value." };
+    }
     if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
         try {
             return { value: JSON.parse(trimmed) };
@@ -10,16 +11,20 @@ export function parseConfigValue(raw) {
             return { error: `Invalid JSON: ${String(err)}` };
         }
     }
-    if (trimmed === "true")
+    if (trimmed === "true") {
         return { value: true };
-    if (trimmed === "false")
+    }
+    if (trimmed === "false") {
         return { value: false };
-    if (trimmed === "null")
+    }
+    if (trimmed === "null") {
         return { value: null };
+    }
     if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
         const num = Number(trimmed);
-        if (Number.isFinite(num))
+        if (Number.isFinite(num)) {
             return { value: num };
+        }
     }
     if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
         (trimmed.startsWith("'") && trimmed.endsWith("'"))) {

package/dist/auto-reply/reply/directive-handling.model-picker.js

@@ -20,12 +20,15 @@ const PROVIDER_RANK = new Map(MODEL_PICK_PROVIDER_PREFERENCE.map((provider, idx)
 function compareProvidersForPicker(a, b) {
     const pa = PROVIDER_RANK.get(a);
     const pb = PROVIDER_RANK.get(b);
-    if (pa !== undefined && pb !== undefined)
+    if (pa !== undefined && pb !== undefined) {
         return pa - pb;
-    if (pa !== undefined)
+    }
+    if (pa !== undefined) {
         return -1;
-    if (pb !== undefined)
+    }
+    if (pb !== undefined) {
         return 1;
+    }
     return a.localeCompare(b);
 }
 export function buildModelPickerItems(catalog) {
@@ -34,19 +37,22 @@ export function buildModelPickerItems(catalog) {
     for (const entry of catalog) {
         const provider = normalizeProviderId(entry.provider);
         const model = entry.id?.trim();
-        if (!provider || !model)
+        if (!provider || !model) {
             continue;
+        }
         const key = `${provider}/${model}`;
-        if (seen.has(key))
+        if (seen.has(key)) {
             continue;
+        }
         seen.add(key);
         out.push({ model, provider });
     }
     // Sort by provider preference first, then by model name
     out.sort((a, b) => {
         const providerOrder = compareProvidersForPicker(a.provider, b.provider);
-        if (providerOrder !== 0)
+        if (providerOrder !== 0) {
             return providerOrder;
+        }
         return a.model.toLowerCase().localeCompare(b.model.toLowerCase());
     });
     return out;

package/dist/auto-reply/reply/directive-handling.persist.js

@@ -7,7 +7,7 @@ import { enqueueSystemEvent } from "../../infra/system-events.js";
 import { applyVerboseOverride } from "../../sessions/level-overrides.js";
 import { applyModelOverrideToSessionEntry } from "../../sessions/model-overrides.js";
 import { resolveProfileOverride } from "./directive-handling.auth.js";
-import { formatElevatedEvent, formatReasoningEvent } from "./directive-handling.shared.js";
+import { enqueueModeSwitchEvents } from "./directive-handling.shared.js";
 export async function persistInlineDirectives(params) {
     const { directives, cfg, sessionEntry, sessionStore, sessionKey, storePath, elevatedEnabled, elevatedAllowed, defaultProvider, defaultModel, aliasIndex, allowedModelKeys, initialModelLabel, formatModelSwitchEvent, agentCfg, } = params;
     let { provider, model } = params;
@@ -27,12 +27,7 @@ export async function persistInlineDirectives(params) {
         let reasoningChanged = directives.hasReasoningDirective && directives.reasoningLevel !== undefined;
         let updated = false;
         if (directives.hasThinkDirective && directives.thinkLevel) {
-            if (directives.thinkLevel === "off") {
-                delete sessionEntry.thinkingLevel;
-            }
-            else {
-                sessionEntry.thinkingLevel = directives.thinkLevel;
-            }
+            sessionEntry.thinkingLevel = directives.thinkLevel;
             updated = true;
         }
         if (directives.hasVerboseDirective && directives.verboseLevel) {
@@ -144,20 +139,13 @@ export async function persistInlineDirectives(params) {
                     store[sessionKey] = sessionEntry;
                 });
             }
-            if (elevatedChanged) {
-                const nextElevated = (sessionEntry.elevatedLevel ?? "off");
-                enqueueSystemEvent(formatElevatedEvent(nextElevated), {
-                    sessionKey,
-                    contextKey: "mode:elevated",
-                });
-            }
-            if (reasoningChanged) {
-                const nextReasoning = (sessionEntry.reasoningLevel ?? "off");
-                enqueueSystemEvent(formatReasoningEvent(nextReasoning), {
-                    sessionKey,
-                    contextKey: "mode:reasoning",
-                });
-            }
+            enqueueModeSwitchEvents({
+                enqueueSystemEvent,
+                sessionEntry,
+                sessionKey,
+                elevatedChanged,
+                reasoningChanged,
+            });
         }
     }
     return {

package/dist/auto-reply/reply/directive-handling.shared.js

@@ -1,10 +1,12 @@
 import { formatCliCommand } from "../../cli/command-format.js";
 export const SYSTEM_MARK = "⚙️";
 export const formatDirectiveAck = (text) => {
-    if (!text)
+    if (!text) {
         return text;
-    if (text.startsWith(SYSTEM_MARK))
+    }
+    if (text.startsWith(SYSTEM_MARK)) {
         return text;
+    }
     return `${SYSTEM_MARK} ${text}`;
 };
 export const formatOptionsLine = (options) => `Options: ${options}.`;
@@ -20,12 +22,30 @@ export const formatElevatedEvent = (level) => {
     return "Elevated OFF — exec stays in sandbox.";
 };
 export const formatReasoningEvent = (level) => {
-    if (level === "stream")
+    if (level === "stream") {
         return "Reasoning STREAM — emit live <think>.";
-    if (level === "on")
+    }
+    if (level === "on") {
         return "Reasoning ON — include <think>.";
+    }
     return "Reasoning OFF — hide <think>.";
 };
+export function enqueueModeSwitchEvents(params) {
+    if (params.elevatedChanged) {
+        const nextElevated = (params.sessionEntry.elevatedLevel ?? "off");
+        params.enqueueSystemEvent(formatElevatedEvent(nextElevated), {
+            sessionKey: params.sessionKey,
+            contextKey: "mode:elevated",
+        });
+    }
+    if (params.reasoningChanged) {
+        const nextReasoning = (params.sessionEntry.reasoningLevel ?? "off");
+        params.enqueueSystemEvent(formatReasoningEvent(nextReasoning), {
+            sessionKey: params.sessionKey,
+            contextKey: "mode:reasoning",
+        });
+    }
+}
 export function formatElevatedUnavailableText(params) {
     const lines = [];
     lines.push(`elevated is not available right now (runtime=${params.runtimeSandboxed ? "sandboxed" : "direct"}).`);

package/dist/auto-reply/reply/followup-runner.js

@@ -111,6 +111,7 @@ export function createFollowupRunner(params) {
                             senderName: queued.run.senderName,
                             senderUsername: queued.run.senderUsername,
                             senderE164: queued.run.senderE164,
+                            senderIsOwner: queued.run.senderIsOwner,
                             sessionFile: queued.run.sessionFile,
                             workspaceDir: queued.run.workspaceDir,
                             config: queued.run.config,

package/dist/auto-reply/reply/get-reply-directives-utils.js

@@ -1,3 +1,19 @@
+const CLEARED_EXEC_FIELDS = {
+    hasExecDirective: false,
+    execHost: undefined,
+    execSecurity: undefined,
+    execAsk: undefined,
+    execNode: undefined,
+    rawExecHost: undefined,
+    rawExecSecurity: undefined,
+    rawExecAsk: undefined,
+    rawExecNode: undefined,
+    hasExecOptions: false,
+    invalidExecHost: false,
+    invalidExecSecurity: false,
+    invalidExecAsk: false,
+    invalidExecNode: false,
+};
 export function clearInlineDirectives(cleaned) {
     return {
         cleaned,
@@ -13,20 +29,7 @@ export function clearInlineDirectives(cleaned) {
         hasElevatedDirective: false,
         elevatedLevel: undefined,
         rawElevatedLevel: undefined,
-        hasExecDirective: false,
-        execHost: undefined,
-        execSecurity: undefined,
-        execAsk: undefined,
-        execNode: undefined,
-        rawExecHost: undefined,
-        rawExecSecurity: undefined,
-        rawExecAsk: undefined,
-        rawExecNode: undefined,
-        hasExecOptions: false,
-        invalidExecHost: false,
-        invalidExecSecurity: false,
-        invalidExecAsk: false,
-        invalidExecNode: false,
+        ...CLEARED_EXEC_FIELDS,
         hasStatusDirective: false,
         hasModelDirective: false,
         rawModelDirective: undefined,
@@ -43,3 +46,9 @@ export function clearInlineDirectives(cleaned) {
         hasQueueOptions: false,
     };
 }
+export function clearExecInlineDirectives(directives) {
+    return {
+        ...directives,
+        ...CLEARED_EXEC_FIELDS,
+    };
+}

package/dist/auto-reply/reply/get-reply-directives.js

@@ -5,7 +5,7 @@ import { resolveBlockStreamingChunking } from "./block-streaming.js";
 import { buildCommandContext } from "./commands.js";
 import { parseInlineDirectives } from "./directive-handling.js";
 import { applyInlineDirectiveOverrides } from "./get-reply-directives-apply.js";
-import { clearInlineDirectives } from "./get-reply-directives-utils.js";
+import { clearExecInlineDirectives, clearInlineDirectives } from "./get-reply-directives-utils.js";
 import { defaultGroupActivation, resolveGroupRequireMention } from "./groups.js";
 import { CURRENT_MESSAGE_MARKER, stripMentions, stripStructuralPrefixes } from "./mentions.js";
 import { createModelSelectionState, resolveContextTokens } from "./model-selection.js";
@@ -17,12 +17,13 @@ function resolveExecOverrides(params) {
         params.sessionEntry?.execSecurity;
     const ask = params.directives.execAsk ?? params.sessionEntry?.execAsk;
     const node = params.directives.execNode ?? params.sessionEntry?.execNode;
-    if (!host && !security && !ask && !node)
+    if (!host && !security && !ask && !node) {
         return undefined;
+    }
     return { host, security, ask, node };
 }
 export async function resolveReplyDirectives(params) {
-    const { ctx, cfg, agentId, agentCfg, agentDir, workspaceDir, sessionCtx, sessionEntry, sessionStore, sessionKey, storePath, sessionScope, groupResolution, isGroup, triggerBodyNormalized, commandAuthorized, defaultProvider, defaultModel, provider: initialProvider, model: initialModel, typing, opts, skillFilter, } = params;
+    const { ctx, cfg, agentId, agentCfg, agentDir, workspaceDir, sessionCtx, sessionEntry, sessionStore, sessionKey, storePath, sessionScope, groupResolution, isGroup, triggerBodyNormalized, commandAuthorized, defaultProvider, defaultModel, provider: initialProvider, model: initialModel, hasResolvedHeartbeatModelOverride, typing, opts, skillFilter, } = params;
     let provider = initialProvider;
     let model = initialModel;
     // Prefer CommandBody/RawBody (clean message without structural context) for directive parsing.
@@ -53,22 +54,24 @@ export async function resolveReplyDirectives(params) {
         surface: command.surface,
         commandSource: ctx.CommandSource,
     });
-    const shouldResolveSkillCommands = allowTextCommands && command.commandBodyNormalized.includes("/");
-    const skillCommands = shouldResolveSkillCommands
+    const reservedCommands = new Set(listChatCommands().flatMap((cmd) => cmd.textAliases.map((a) => a.replace(/^\//, "").toLowerCase())));
+    const rawAliases = Object.values(cfg.agents?.defaults?.models ?? {})
+        .map((entry) => entry.alias?.trim())
+        .filter((alias) => Boolean(alias))
+        .filter((alias) => !reservedCommands.has(alias.toLowerCase()));
+    // Only load workspace skill commands when we actually need them to filter aliases.
+    // This avoids scanning skills for messages that only use inline directives like /think:/verbose:.
+    const skillCommands = allowTextCommands && rawAliases.length > 0
         ? listSkillCommandsForWorkspace({
             workspaceDir,
             cfg,
             skillFilter,
         })
         : [];
-    const reservedCommands = new Set(listChatCommands().flatMap((cmd) => cmd.textAliases.map((a) => a.replace(/^\//, "").toLowerCase())));
     for (const command of skillCommands) {
         reservedCommands.add(command.name.toLowerCase());
     }
-    const configuredAliases = Object.values(cfg.agents?.defaults?.models ?? {})
-        .map((entry) => entry.alias?.trim())
-        .filter((alias) => Boolean(alias))
-        .filter((alias) => !reservedCommands.has(alias.toLowerCase()));
+    const configuredAliases = rawAliases.filter((alias) => !reservedCommands.has(alias.toLowerCase()));
     const allowStatusDirective = allowTextCommands && command.isAuthorizedSender;
     let parsedDirectives = parseInlineDirectives(commandText, {
         modelAliases: configuredAliases,
@@ -93,23 +96,7 @@ export async function resolveReplyDirectives(params) {
     }
     if (isGroup && ctx.WasMentioned !== true && parsedDirectives.hasExecDirective) {
         if (parsedDirectives.execSecurity !== "deny") {
-            parsedDirectives = {
-                ...parsedDirectives,
-                hasExecDirective: false,
-                execHost: undefined,
-                execSecurity: undefined,
-                execAsk: undefined,
-                execNode: undefined,
-                rawExecHost: undefined,
-                rawExecSecurity: undefined,
-                rawExecAsk: undefined,
-                rawExecNode: undefined,
-                hasExecOptions: false,
-                invalidExecHost: false,
-                invalidExecSecurity: false,
-                invalidExecAsk: false,
-                invalidExecNode: false,
-            };
+            parsedDirectives = clearExecInlineDirectives(parsedDirectives);
         }
     }
     const hasInlineDirective = parsedDirectives.hasThinkDirective ||
@@ -151,8 +138,9 @@ export async function resolveReplyDirectives(params) {
         };
     const existingBody = sessionCtx.BodyStripped ?? sessionCtx.Body ?? "";
     let cleanedBody = (() => {
-        if (!existingBody)
+        if (!existingBody) {
             return parsedDirectives.cleaned;
+        }
         if (!sessionCtx.CommandBody && !sessionCtx.RawBody) {
             return parseInlineDirectives(existingBody, {
                 modelAliases: configuredAliases,
@@ -253,6 +241,7 @@ export async function resolveReplyDirectives(params) {
         provider,
         model,
         hasModelDirective: directives.hasModelDirective,
+        hasResolvedHeartbeatModelOverride,
     });
     provider = modelState.provider;
     model = modelState.model;

package/dist/auto-reply/reply/get-reply-inline-actions.js

@@ -136,6 +136,7 @@ export async function handleInlineActions(params) {
             command,
             sessionEntry,
             sessionKey,
+            parentSessionKey: ctx.ParentSessionKey,
             sessionScope,
             provider,
             model,

package/dist/auto-reply/reply/get-reply.js

@@ -1,24 +1,49 @@
-import { resolveAgentDir, resolveAgentWorkspaceDir, resolveSessionAgentId, } from "../../agents/agent-scope.js";
+import { resolveAgentDir, resolveAgentWorkspaceDir, resolveSessionAgentId, resolveAgentSkillsFilter, } from "../../agents/agent-scope.js";
 import { resolveModelRefFromString } from "../../agents/model-selection.js";
 import { resolveAgentTimeoutMs } from "../../agents/timeout.js";
 import { DEFAULT_AGENT_WORKSPACE_DIR, ensureAgentWorkspace } from "../../agents/workspace.js";
+import { resolveChannelModelOverride } from "../../channels/model-overrides.js";
 import { loadConfig } from "../../config/config.js";
+import { applyLinkUnderstanding } from "../../link-understanding/apply.js";
+import { applyMediaUnderstanding } from "../../media-understanding/apply.js";
 import { defaultRuntime } from "../../runtime.js";
 import { resolveCommandAuthorization } from "../command-auth.js";
 import { SILENT_REPLY_TOKEN } from "../tokens.js";
-import { applyMediaUnderstanding } from "../../media-understanding/apply.js";
-import { applyLinkUnderstanding } from "../../link-understanding/apply.js";
 import { resolveDefaultModel } from "./directive-handling.js";
 import { resolveReplyDirectives } from "./get-reply-directives.js";
 import { handleInlineActions } from "./get-reply-inline-actions.js";
 import { runPreparedReply } from "./get-reply-run.js";
 import { finalizeInboundContext } from "./inbound-context.js";
-import { initSessionState } from "./session.js";
 import { applyResetModelOverride } from "./session-reset-model.js";
+import { initSessionState } from "./session.js";
 import { stageSandboxMedia } from "./stage-sandbox-media.js";
 import { createTypingController } from "./typing.js";
+function mergeSkillFilters(channelFilter, agentFilter) {
+    const normalize = (list) => {
+        if (!Array.isArray(list)) {
+            return undefined;
+        }
+        return list.map((entry) => String(entry).trim()).filter(Boolean);
+    };
+    const channel = normalize(channelFilter);
+    const agent = normalize(agentFilter);
+    if (!channel && !agent) {
+        return undefined;
+    }
+    if (!channel) {
+        return agent;
+    }
+    if (!agent) {
+        return channel;
+    }
+    if (channel.length === 0 || agent.length === 0) {
+        return [];
+    }
+    const agentSet = new Set(agent);
+    return channel.filter((name) => agentSet.has(name));
+}
 export async function getReplyFromConfig(ctx, opts, configOverride) {
-    const isFastTestEnv = process.env.POOLBOT_TEST_FAST === "1" || process.env.CLAWDBOT_TEST_FAST === "1";
+    const isFastTestEnv = process.env.POOLBOT_TEST_FAST === "1";
     const cfg = configOverride ?? loadConfig();
     const targetSessionKey = ctx.CommandSource === "native" ? ctx.CommandTargetSessionKey?.trim() : undefined;
     const agentSessionKey = targetSessionKey || ctx.SessionKey;
@@ -26,6 +51,8 @@ export async function getReplyFromConfig(ctx, opts, configOverride) {
         sessionKey: agentSessionKey,
         config: cfg,
     });
+    const mergedSkillFilter = mergeSkillFilters(opts?.skillFilter, resolveAgentSkillsFilter(cfg, agentId));
+    const resolvedOpts = mergedSkillFilter !== undefined ? { ...opts, skillFilter: mergedSkillFilter } : opts;
     const agentCfg = cfg.agents?.defaults;
     const sessionCfg = cfg.session;
     const { defaultProvider, defaultModel, aliasIndex } = resolveDefaultModel({
@@ -34,8 +61,11 @@ export async function getReplyFromConfig(ctx, opts, configOverride) {
     });
     let provider = defaultProvider;
     let model = defaultModel;
+    let hasResolvedHeartbeatModelOverride = false;
     if (opts?.isHeartbeat) {
-        const heartbeatRaw = agentCfg?.heartbeat?.model?.trim() ?? "";
+        // Prefer the resolved per-agent heartbeat model passed from the heartbeat runner,
+        // fall back to the global defaults heartbeat model for backward compatibility.
+        const heartbeatRaw = opts.heartbeatModelOverride?.trim() ?? agentCfg?.heartbeat?.model?.trim() ?? "";
         const heartbeatRef = heartbeatRaw
             ? resolveModelRefFromString({
                 raw: heartbeatRaw,
@@ -46,6 +76,7 @@ export async function getReplyFromConfig(ctx, opts, configOverride) {
         if (heartbeatRef) {
             provider = heartbeatRef.ref.provider;
             model = heartbeatRef.ref.model;
+            hasResolvedHeartbeatModelOverride = true;
         }
     }
     const workspaceDirRaw = resolveAgentWorkspaceDir(cfg, agentId) ?? DEFAULT_AGENT_WORKSPACE_DIR;
@@ -55,11 +86,12 @@ export async function getReplyFromConfig(ctx, opts, configOverride) {
     });
     const workspaceDir = workspace.dir;
     const agentDir = resolveAgentDir(cfg, agentId);
-    const timeoutMs = resolveAgentTimeoutMs({ cfg });
+    const timeoutMs = resolveAgentTimeoutMs({ cfg, overrideSeconds: opts?.timeoutOverrideSeconds });
     const configuredTypingSeconds = agentCfg?.typingIntervalSeconds ?? sessionCfg?.typingIntervalSeconds;
     const typingIntervalSeconds = typeof configuredTypingSeconds === "number" ? configuredTypingSeconds : 6;
     const typing = createTypingController({
         onReplyStart: opts?.onReplyStart,
+        onCleanup: opts?.onTypingCleanup,
         typingIntervalSeconds,
         silentToken: SILENT_REPLY_TOKEN,
         log: defaultRuntime.log,
@@ -104,6 +136,32 @@ export async function getReplyFromConfig(ctx, opts, configOverride) {
         defaultModel,
         aliasIndex,
     });
+    const channelModelOverride = resolveChannelModelOverride({
+        cfg,
+        channel: groupResolution?.channel ??
+            sessionEntry.channel ??
+            sessionEntry.origin?.provider ??
+            (typeof finalized.OriginatingChannel === "string"
+                ? finalized.OriginatingChannel
+                : undefined) ??
+            finalized.Provider,
+        groupId: groupResolution?.id ?? sessionEntry.groupId,
+        groupChannel: sessionEntry.groupChannel ?? sessionCtx.GroupChannel ?? finalized.GroupChannel,
+        groupSubject: sessionEntry.subject ?? sessionCtx.GroupSubject ?? finalized.GroupSubject,
+        parentSessionKey: sessionCtx.ParentSessionKey,
+    });
+    const hasSessionModelOverride = Boolean(sessionEntry.modelOverride?.trim() || sessionEntry.providerOverride?.trim());
+    if (!hasResolvedHeartbeatModelOverride && !hasSessionModelOverride && channelModelOverride) {
+        const resolved = resolveModelRefFromString({
+            raw: channelModelOverride.model,
+            defaultProvider,
+            aliasIndex,
+        });
+        if (resolved) {
+            provider = resolved.ref.provider;
+            model = resolved.ref.model;
+        }
+    }
     const directiveResult = await resolveReplyDirectives({
         ctx: finalized,
         cfg,
@@ -126,9 +184,10 @@ export async function getReplyFromConfig(ctx, opts, configOverride) {
         aliasIndex,
         provider,
         model,
+        hasResolvedHeartbeatModelOverride,
         typing,
-        opts,
-        skillFilter: opts?.skillFilter,
+        opts: resolvedOpts,
+        skillFilter: mergedSkillFilter,
     });
     if (directiveResult.kind === "reply") {
         return directiveResult.reply;
@@ -150,7 +209,7 @@ export async function getReplyFromConfig(ctx, opts, configOverride) {
         sessionScope,
         workspaceDir,
         isGroup,
-        opts,
+        opts: resolvedOpts,
         typing,
         allowTextCommands,
         inlineStatusRequested,
@@ -172,7 +231,7 @@ export async function getReplyFromConfig(ctx, opts, configOverride) {
         contextTokens,
         directiveAck,
         abortedLastRun,
-        skillFilter: opts?.skillFilter,
+        skillFilter: mergedSkillFilter,
     });
     if (inlineActionResult.kind === "reply") {
         return inlineActionResult.reply;
@@ -216,7 +275,7 @@ export async function getReplyFromConfig(ctx, opts, configOverride) {
         perMessageQueueMode,
         perMessageQueueOptions,
         typing,
-        opts,
+        opts: resolvedOpts,
         defaultProvider,
         defaultModel,
         timeoutMs,