@poolzin/pool-bot 2026.2.20 → 2026.2.22

package/dist/agents/cli-backends.js

@@ -1,14 +1,19 @@
+import { CLI_FRESH_WATCHDOG_DEFAULTS, CLI_RESUME_WATCHDOG_DEFAULTS, } from "./cli-watchdog-defaults.js";
 import { normalizeProviderId } from "./model-selection.js";
 const CLAUDE_MODEL_ALIASES = {
     opus: "opus",
+    "opus-4.6": "opus",
     "opus-4.5": "opus",
     "opus-4": "opus",
+    "claude-opus-4-6": "opus",
     "claude-opus-4-5": "opus",
     "claude-opus-4": "opus",
     sonnet: "sonnet",
+    "sonnet-4.6": "sonnet",
     "sonnet-4.5": "sonnet",
     "sonnet-4.1": "sonnet",
     "sonnet-4.0": "sonnet",
+    "claude-sonnet-4-6": "sonnet",
     "claude-sonnet-4-5": "sonnet",
     "claude-sonnet-4-1": "sonnet",
     "claude-sonnet-4-0": "sonnet",
@@ -38,6 +43,12 @@ const DEFAULT_CLAUDE_BACKEND = {
     systemPromptMode: "append",
     systemPromptWhen: "first",
     clearEnv: ["ANTHROPIC_API_KEY", "ANTHROPIC_API_KEY_OLD"],
+    reliability: {
+        watchdog: {
+            fresh: { ...CLI_FRESH_WATCHDOG_DEFAULTS },
+            resume: { ...CLI_RESUME_WATCHDOG_DEFAULTS },
+        },
+    },
     serialize: true,
 };
 const DEFAULT_CODEX_BACKEND = {
@@ -61,6 +72,12 @@ const DEFAULT_CODEX_BACKEND = {
     sessionMode: "existing",
     imageArg: "--image",
     imageMode: "repeat",
+    reliability: {
+        watchdog: {
+            fresh: { ...CLI_FRESH_WATCHDOG_DEFAULTS },
+            resume: { ...CLI_RESUME_WATCHDOG_DEFAULTS },
+        },
+    },
     serialize: true,
 };
 function normalizeBackendKey(key) {
@@ -68,14 +85,20 @@ function normalizeBackendKey(key) {
 }
 function pickBackendConfig(config, normalizedId) {
     for (const [key, entry] of Object.entries(config)) {
-        if (normalizeBackendKey(key) === normalizedId)
+        if (normalizeBackendKey(key) === normalizedId) {
             return entry;
+        }
     }
     return undefined;
 }
 function mergeBackendConfig(base, override) {
-    if (!override)
+    if (!override) {
         return { ...base };
+    }
+    const baseFresh = base.reliability?.watchdog?.fresh ?? {};
+    const baseResume = base.reliability?.watchdog?.resume ?? {};
+    const overrideFresh = override.reliability?.watchdog?.fresh ?? {};
+    const overrideResume = override.reliability?.watchdog?.resume ?? {};
     return {
         ...base,
         ...override,
@@ -86,6 +109,22 @@ function mergeBackendConfig(base, override) {
         sessionIdFields: override.sessionIdFields ?? base.sessionIdFields,
         sessionArgs: override.sessionArgs ?? base.sessionArgs,
         resumeArgs: override.resumeArgs ?? base.resumeArgs,
+        reliability: {
+            ...base.reliability,
+            ...override.reliability,
+            watchdog: {
+                ...base.reliability?.watchdog,
+                ...override.reliability?.watchdog,
+                fresh: {
+                    ...baseFresh,
+                    ...overrideFresh,
+                },
+                resume: {
+                    ...baseResume,
+                    ...overrideResume,
+                },
+            },
+        },
     };
 }
 export function resolveCliBackendIds(cfg) {
@@ -106,21 +145,25 @@ export function resolveCliBackendConfig(provider, cfg) {
     if (normalized === "claude-cli") {
         const merged = mergeBackendConfig(DEFAULT_CLAUDE_BACKEND, override);
         const command = merged.command?.trim();
-        if (!command)
+        if (!command) {
             return null;
+        }
         return { id: normalized, config: { ...merged, command } };
     }
     if (normalized === "codex-cli") {
         const merged = mergeBackendConfig(DEFAULT_CODEX_BACKEND, override);
         const command = merged.command?.trim();
-        if (!command)
+        if (!command) {
             return null;
+        }
         return { id: normalized, config: { ...merged, command } };
     }
-    if (!override)
+    if (!override) {
         return null;
+    }
     const command = override.command?.trim();
-    if (!command)
+    if (!command) {
         return null;
+    }
     return { id: normalized, config: { ...override, command } };
 }

package/dist/agents/cli-runner/helpers.js

@@ -2,120 +2,22 @@ import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { runExec } from "../../process/exec.js";
 import { buildTtsSystemPromptHint } from "../../tts/tts.js";
-import { escapeRegExp, isRecord } from "../../utils.js";
+import { isRecord } from "../../utils.js";
+import { buildModelAliasLines } from "../model-alias-lines.js";
 import { resolveDefaultModelForAgent } from "../model-selection.js";
 import { detectRuntimeShell } from "../shell-utils.js";
 import { buildSystemPromptParams } from "../system-prompt-params.js";
 import { buildAgentSystemPrompt } from "../system-prompt.js";
+export { buildCliSupervisorScopeKey, resolveCliNoOutputTimeoutMs } from "./reliability.js";
 const CLI_RUN_QUEUE = new Map();
-export async function cleanupResumeProcesses(backend, sessionId) {
-    if (process.platform === "win32")
-        return;
-    const resumeArgs = backend.resumeArgs ?? [];
-    if (resumeArgs.length === 0)
-        return;
-    if (!resumeArgs.some((arg) => arg.includes("{sessionId}")))
-        return;
-    const commandToken = path.basename(backend.command ?? "").trim();
-    if (!commandToken)
-        return;
-    const resumeTokens = resumeArgs.map((arg) => arg.replaceAll("{sessionId}", sessionId));
-    const pattern = [commandToken, ...resumeTokens]
-        .filter(Boolean)
-        .map((token) => escapeRegExp(token))
-        .join(".*");
-    if (!pattern)
-        return;
-    try {
-        await runExec("pkill", ["-f", pattern]);
-    }
-    catch {
-        // ignore missing pkill or no matches
-    }
-}
-function buildSessionMatchers(backend) {
-    const commandToken = path.basename(backend.command ?? "").trim();
-    if (!commandToken)
-        return [];
-    const matchers = [];
-    const sessionArg = backend.sessionArg?.trim();
-    const sessionArgs = backend.sessionArgs ?? [];
-    const resumeArgs = backend.resumeArgs ?? [];
-    const addMatcher = (args) => {
-        if (args.length === 0)
-            return;
-        const tokens = [commandToken, ...args];
-        const pattern = tokens
-            .map((token, index) => {
-            const tokenPattern = tokenToRegex(token);
-            return index === 0 ? `(?:^|\\s)${tokenPattern}` : `\\s+${tokenPattern}`;
-        })
-            .join("");
-        matchers.push(new RegExp(pattern));
-    };
-    if (sessionArgs.some((arg) => arg.includes("{sessionId}"))) {
-        addMatcher(sessionArgs);
-    }
-    else if (sessionArg) {
-        addMatcher([sessionArg, "{sessionId}"]);
-    }
-    if (resumeArgs.some((arg) => arg.includes("{sessionId}"))) {
-        addMatcher(resumeArgs);
-    }
-    return matchers;
-}
-function tokenToRegex(token) {
-    if (!token.includes("{sessionId}"))
-        return escapeRegExp(token);
-    const parts = token.split("{sessionId}").map((part) => escapeRegExp(part));
-    return parts.join("\\S+");
-}
-/**
- * Cleanup suspended Poolbot CLI processes that have accumulated.
- * Only cleans up if there are more than the threshold (default: 10).
- */
-export async function cleanupSuspendedCliProcesses(backend, threshold = 10) {
-    if (process.platform === "win32")
-        return;
-    const matchers = buildSessionMatchers(backend);
-    if (matchers.length === 0)
-        return;
-    try {
-        const { stdout } = await runExec("ps", ["-ax", "-o", "pid=,stat=,command="]);
-        const suspended = [];
-        for (const line of stdout.split("\n")) {
-            const trimmed = line.trim();
-            if (!trimmed)
-                continue;
-            const match = /^(\d+)\s+(\S+)\s+(.*)$/.exec(trimmed);
-            if (!match)
-                continue;
-            const pid = Number(match[1]);
-            const stat = match[2] ?? "";
-            const command = match[3] ?? "";
-            if (!Number.isFinite(pid))
-                continue;
-            if (!stat.includes("T"))
-                continue;
-            if (!matchers.some((matcher) => matcher.test(command)))
-                continue;
-            suspended.push(pid);
-        }
-        if (suspended.length > threshold) {
-            // Verified locally: stopped (T) processes ignore SIGTERM, so use SIGKILL.
-            await runExec("kill", ["-9", ...suspended.map((pid) => String(pid))]);
-        }
-    }
-    catch {
-        // ignore errors - best effort cleanup
-    }
-}
 export function enqueueCliRun(key, task) {
     const prior = CLI_RUN_QUEUE.get(key) ?? Promise.resolve();
     const chained = prior.catch(() => undefined).then(task);
-    const tracked = chained.finally(() => {
+    // Keep queue continuity even when a run rejects, without emitting unhandled rejections.
+    const tracked = chained
+        .catch(() => undefined)
+        .finally(() => {
         if (CLI_RUN_QUEUE.get(key) === tracked) {
             CLI_RUN_QUEUE.delete(key);
         }
@@ -123,22 +25,6 @@ export function enqueueCliRun(key, task) {
     CLI_RUN_QUEUE.set(key, tracked);
     return chained;
 }
-function buildModelAliasLines(cfg) {
-    const models = cfg?.agents?.defaults?.models ?? {};
-    const entries = [];
-    for (const [keyRaw, entryRaw] of Object.entries(models)) {
-        const model = String(keyRaw ?? "").trim();
-        if (!model)
-            continue;
-        const alias = String(entryRaw?.alias ?? "").trim();
-        if (!alias)
-            continue;
-        entries.push({ alias, model });
-    }
-    return entries
-        .sort((a, b) => a.alias.localeCompare(b.alias))
-        .map((entry) => `- ${entry.alias}: ${entry.model}`);
-}
 export function buildSystemPrompt(params) {
     const defaultModelRef = resolveDefaultModelForAgent({
         cfg: params.config ?? {},
@@ -182,15 +68,18 @@ export function buildSystemPrompt(params) {
 }
 export function normalizeCliModel(modelId, backend) {
     const trimmed = modelId.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return trimmed;
+    }
     const direct = backend.modelAliases?.[trimmed];
-    if (direct)
+    if (direct) {
         return direct;
+    }
     const lower = trimmed.toLowerCase();
     const mapped = backend.modelAliases?.[lower];
-    if (mapped)
+    if (mapped) {
         return mapped;
+    }
     return trimmed;
 }
 function toUsage(raw) {
@@ -200,27 +89,36 @@ function toUsage(raw) {
     const cacheRead = pick("cache_read_input_tokens") ?? pick("cached_input_tokens") ?? pick("cacheRead");
     const cacheWrite = pick("cache_write_input_tokens") ?? pick("cacheWrite");
     const total = pick("total_tokens") ?? pick("total");
-    if (!input && !output && !cacheRead && !cacheWrite && !total)
+    if (!input && !output && !cacheRead && !cacheWrite && !total) {
         return undefined;
+    }
     return { input, output, cacheRead, cacheWrite, total };
 }
 function collectText(value) {
-    if (!value)
+    if (!value) {
         return "";
-    if (typeof value === "string")
+    }
+    if (typeof value === "string") {
         return value;
-    if (Array.isArray(value))
+    }
+    if (Array.isArray(value)) {
         return value.map((entry) => collectText(entry)).join("");
-    if (!isRecord(value))
+    }
+    if (!isRecord(value)) {
         return "";
-    if (typeof value.text === "string")
+    }
+    if (typeof value.text === "string") {
         return value.text;
-    if (typeof value.content === "string")
+    }
+    if (typeof value.content === "string") {
         return value.content;
-    if (Array.isArray(value.content))
+    }
+    if (Array.isArray(value.content)) {
         return value.content.map((entry) => collectText(entry)).join("");
-    if (isRecord(value.message))
+    }
+    if (isRecord(value.message)) {
         return collectText(value.message);
+    }
     return "";
 }
 function pickSessionId(parsed, backend) {
@@ -232,15 +130,17 @@ function pickSessionId(parsed, backend) {
     ];
     for (const field of fields) {
         const value = parsed[field];
-        if (typeof value === "string" && value.trim())
+        if (typeof value === "string" && value.trim()) {
             return value.trim();
+        }
     }
     return undefined;
 }
 export function parseCliJson(raw, backend) {
     const trimmed = raw.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return null;
+    }
     let parsed;
     try {
         parsed = JSON.parse(trimmed);
@@ -248,8 +148,9 @@ export function parseCliJson(raw, backend) {
     catch {
         return null;
     }
-    if (!isRecord(parsed))
+    if (!isRecord(parsed)) {
         return null;
+    }
     const sessionId = pickSessionId(parsed, backend);
     const usage = isRecord(parsed.usage) ? toUsage(parsed.usage) : undefined;
     const text = collectText(parsed.message) ||
@@ -263,8 +164,9 @@ export function parseCliJsonl(raw, backend) {
         .split(/\r?\n/g)
         .map((line) => line.trim())
         .filter(Boolean);
-    if (lines.length === 0)
+    if (lines.length === 0) {
         return null;
+    }
     let sessionId;
     let usage;
     const texts = [];
@@ -276,10 +178,12 @@ export function parseCliJsonl(raw, backend) {
         catch {
             continue;
         }
-        if (!isRecord(parsed))
+        if (!isRecord(parsed)) {
             continue;
-        if (!sessionId)
+        }
+        if (!sessionId) {
             sessionId = pickSessionId(parsed, backend);
+        }
         if (!sessionId && typeof parsed.thread_id === "string") {
             sessionId = parsed.thread_id.trim();
         }
@@ -295,32 +199,40 @@ export function parseCliJsonl(raw, backend) {
         }
     }
     const text = texts.join("\n").trim();
-    if (!text)
+    if (!text) {
         return null;
+    }
     return { text, sessionId, usage };
 }
 export function resolveSystemPromptUsage(params) {
     const systemPrompt = params.systemPrompt?.trim();
-    if (!systemPrompt)
+    if (!systemPrompt) {
         return null;
+    }
     const when = params.backend.systemPromptWhen ?? "first";
-    if (when === "never")
+    if (when === "never") {
         return null;
-    if (when === "first" && !params.isNewSession)
+    }
+    if (when === "first" && !params.isNewSession) {
         return null;
-    if (!params.backend.systemPromptArg?.trim())
+    }
+    if (!params.backend.systemPromptArg?.trim()) {
         return null;
+    }
     return systemPrompt;
 }
 export function resolveSessionIdToSend(params) {
     const mode = params.backend.sessionMode ?? "always";
     const existing = params.cliSessionId?.trim();
-    if (mode === "none")
+    if (mode === "none") {
         return { sessionId: undefined, isNew: !existing };
-    if (mode === "existing")
+    }
+    if (mode === "existing") {
         return { sessionId: existing, isNew: !existing };
-    if (existing)
+    }
+    if (existing) {
         return { sessionId: existing, isNew: false };
+    }
     return { sessionId: crypto.randomUUID(), isNew: true };
 }
 export function resolvePromptInput(params) {
@@ -335,19 +247,24 @@ export function resolvePromptInput(params) {
 }
 function resolveImageExtension(mimeType) {
     const normalized = mimeType.toLowerCase();
-    if (normalized.includes("png"))
+    if (normalized.includes("png")) {
         return "png";
-    if (normalized.includes("jpeg") || normalized.includes("jpg"))
+    }
+    if (normalized.includes("jpeg") || normalized.includes("jpg")) {
         return "jpg";
-    if (normalized.includes("gif"))
+    }
+    if (normalized.includes("gif")) {
         return "gif";
-    if (normalized.includes("webp"))
+    }
+    if (normalized.includes("webp")) {
         return "webp";
+    }
     return "bin";
 }
 export function appendImagePathsToPrompt(prompt, paths) {
-    if (!paths.length)
+    if (!paths.length) {
         return prompt;
+    }
     const trimmed = prompt.trimEnd();
     const separator = trimmed ? "\n\n" : "";
     return `${trimmed}${separator}${paths.join("\n")}`;

package/dist/agents/cli-runner.js

@@ -1,20 +1,32 @@
 import { resolveHeartbeatPrompt } from "../auto-reply/heartbeat.js";
-import { isTruthyEnvValue } from "../infra/env.js";
 import { shouldLogVerbose } from "../globals.js";
+import { isTruthyEnvValue } from "../infra/env.js";
 import { createSubsystemLogger } from "../logging/subsystem.js";
-import { runCommandWithTimeout } from "../process/exec.js";
-import { resolveUserPath } from "../utils.js";
-import { resolvePoolbotDocsPath } from "./docs-path.js";
+import { getProcessSupervisor } from "../process/supervisor/index.js";
 import { resolveSessionAgentIds } from "./agent-scope.js";
 import { makeBootstrapWarn, resolveBootstrapContextForRun } from "./bootstrap-files.js";
 import { resolveCliBackendConfig } from "./cli-backends.js";
-import { appendImagePathsToPrompt, buildCliArgs, buildSystemPrompt, cleanupResumeProcesses, cleanupSuspendedCliProcesses, enqueueCliRun, normalizeCliModel, parseCliJson, parseCliJsonl, resolvePromptInput, resolveSessionIdToSend, resolveSystemPromptUsage, writeCliImages, } from "./cli-runner/helpers.js";
+import { appendImagePathsToPrompt, buildCliSupervisorScopeKey, buildCliArgs, buildSystemPrompt, enqueueCliRun, normalizeCliModel, parseCliJson, parseCliJsonl, resolveCliNoOutputTimeoutMs, resolvePromptInput, resolveSessionIdToSend, resolveSystemPromptUsage, writeCliImages, } from "./cli-runner/helpers.js";
+import { resolvePoolbotDocsPath } from "./docs-path.js";
 import { FailoverError, resolveFailoverStatus } from "./failover-error.js";
 import { classifyFailoverReason, isFailoverErrorMessage } from "./pi-embedded-helpers.js";
+import { redactRunIdentifier, resolveRunWorkspaceDir } from "./workspace-run.js";
 const log = createSubsystemLogger("agent/claude-cli");
 export async function runCliAgent(params) {
     const started = Date.now();
-    const resolvedWorkspace = resolveUserPath(params.workspaceDir);
+    const workspaceResolution = resolveRunWorkspaceDir({
+        workspaceDir: params.workspaceDir,
+        sessionKey: params.sessionKey,
+        agentId: params.agentId,
+        config: params.config,
+    });
+    const resolvedWorkspace = workspaceResolution.workspaceDir;
+    const redactedSessionId = redactRunIdentifier(params.sessionId);
+    const redactedSessionKey = redactRunIdentifier(params.sessionKey);
+    const redactedWorkspace = redactRunIdentifier(resolvedWorkspace);
+    if (workspaceResolution.usedFallback) {
+        log.warn(`[workspace-fallback] caller=runCliAgent reason=${workspaceResolution.fallbackReason} run=${params.runId} session=${redactedSessionId} sessionKey=${redactedSessionKey} agent=${workspaceResolution.agentId} workspace=${redactedWorkspace}`);
+    }
     const workspaceDir = resolvedWorkspace;
     const backendResolved = resolveCliBackendConfig(params.provider, params.config);
     if (!backendResolved) {
@@ -117,7 +129,7 @@ export async function runCliAgent(params) {
     try {
         const output = await enqueueCliRun(queueKey, async () => {
             log.info(`cli exec: provider=${params.provider} model=${normalizedModel} promptChars=${params.prompt.length}`);
-            const logOutputText = isTruthyEnvValue(process.env.POOLBOT_CLAUDE_CLI_LOG_OUTPUT || process.env.CLAWDBOT_CLAUDE_CLI_LOG_OUTPUT);
+            const logOutputText = isTruthyEnvValue(process.env.POOLBOT_CLAUDE_CLI_LOG_OUTPUT);
             if (logOutputText) {
                 const logArgs = [];
                 for (let i = 0; i < args.length; i += 1) {
@@ -160,32 +172,69 @@ export async function runCliAgent(params) {
                 }
                 return next;
             })();
-            // Cleanup suspended processes that have accumulated (regardless of sessionId)
-            await cleanupSuspendedCliProcesses(backend);
-            if (useResume && cliSessionIdToSend) {
-                await cleanupResumeProcesses(backend, cliSessionIdToSend);
-            }
-            const result = await runCommandWithTimeout([backend.command, ...args], {
+            const noOutputTimeoutMs = resolveCliNoOutputTimeoutMs({
+                backend,
                 timeoutMs: params.timeoutMs,
+                useResume,
+            });
+            const supervisor = getProcessSupervisor();
+            const scopeKey = buildCliSupervisorScopeKey({
+                backend,
+                backendId: backendResolved.id,
+                cliSessionId: useResume ? cliSessionIdToSend : undefined,
+            });
+            const managedRun = await supervisor.spawn({
+                sessionId: params.sessionId,
+                backendId: backendResolved.id,
+                scopeKey,
+                replaceExistingScope: Boolean(useResume && scopeKey),
+                mode: "child",
+                argv: [backend.command, ...args],
+                timeoutMs: params.timeoutMs,
+                noOutputTimeoutMs,
                 cwd: workspaceDir,
                 env,
                 input: stdinPayload,
             });
+            const result = await managedRun.wait();
             const stdout = result.stdout.trim();
             const stderr = result.stderr.trim();
             if (logOutputText) {
-                if (stdout)
+                if (stdout) {
                     log.info(`cli stdout:\n${stdout}`);
-                if (stderr)
+                }
+                if (stderr) {
                     log.info(`cli stderr:\n${stderr}`);
+                }
             }
             if (shouldLogVerbose()) {
-                if (stdout)
+                if (stdout) {
                     log.debug(`cli stdout:\n${stdout}`);
-                if (stderr)
+                }
+                if (stderr) {
                     log.debug(`cli stderr:\n${stderr}`);
+                }
             }
-            if (result.code !== 0) {
+            if (result.exitCode !== 0 || result.reason !== "exit") {
+                if (result.reason === "no-output-timeout" || result.noOutputTimedOut) {
+                    const timeoutReason = `CLI produced no output for ${Math.round(noOutputTimeoutMs / 1000)}s and was terminated.`;
+                    log.warn(`cli watchdog timeout: provider=${params.provider} model=${modelId} session=${cliSessionIdToSend ?? params.sessionId} noOutputTimeoutMs=${noOutputTimeoutMs} pid=${managedRun.pid ?? "unknown"}`);
+                    throw new FailoverError(timeoutReason, {
+                        reason: "timeout",
+                        provider: params.provider,
+                        model: modelId,
+                        status: resolveFailoverStatus("timeout"),
+                    });
+                }
+                if (result.reason === "overall-timeout") {
+                    const timeoutReason = `CLI exceeded timeout (${Math.round(params.timeoutMs / 1000)}s) and was terminated.`;
+                    throw new FailoverError(timeoutReason, {
+                        reason: "timeout",
+                        provider: params.provider,
+                        model: modelId,
+                        status: resolveFailoverStatus("timeout"),
+                    });
+                }
                 const err = stderr || stdout || "CLI failed.";
                 const reason = classifyFailoverReason(err) ?? "unknown";
                 const status = resolveFailoverStatus(reason);
@@ -223,8 +272,9 @@ export async function runCliAgent(params) {
         };
     }
     catch (err) {
-        if (err instanceof FailoverError)
+        if (err instanceof FailoverError) {
             throw err;
+        }
         const message = err instanceof Error ? err.message : String(err);
         if (isFailoverErrorMessage(message)) {
             const reason = classifyFailoverReason(message) ?? "unknown";
@@ -248,6 +298,7 @@ export async function runClaudeCliAgent(params) {
     return runCliAgent({
         sessionId: params.sessionId,
         sessionKey: params.sessionKey,
+        agentId: params.agentId,
         sessionFile: params.sessionFile,
         workspaceDir: params.workspaceDir,
         config: params.config,

package/dist/agents/identity.js

@@ -3,11 +3,30 @@ const DEFAULT_ACK_REACTION = "👀";
 export function resolveAgentIdentity(cfg, agentId) {
     return resolveAgentConfig(cfg, agentId)?.identity;
 }
-export function resolveAckReaction(cfg, agentId) {
+export function resolveAckReaction(cfg, agentId, opts) {
+    // L1: Channel account level
+    if (opts?.channel && opts?.accountId) {
+        const channelCfg = getChannelConfig(cfg, opts.channel);
+        const accounts = channelCfg?.accounts;
+        const accountReaction = accounts?.[opts.accountId]?.ackReaction;
+        if (accountReaction !== undefined) {
+            return accountReaction.trim();
+        }
+    }
+    // L2: Channel level
+    if (opts?.channel) {
+        const channelCfg = getChannelConfig(cfg, opts.channel);
+        const channelReaction = channelCfg?.ackReaction;
+        if (channelReaction !== undefined) {
+            return channelReaction.trim();
+        }
+    }
+    // L3: Global messages level
     const configured = cfg.messages?.ackReaction;
     if (configured !== undefined) {
         return configured.trim();
     }
+    // L4: Agent identity emoji fallback
     const emoji = resolveAgentIdentity(cfg, agentId)?.emoji?.trim();
     return emoji || DEFAULT_ACK_REACTION;
 }

package/dist/agents/image-sanitization.js

@@ -0,0 +1,9 @@
+export const DEFAULT_IMAGE_MAX_DIMENSION_PX = 1200;
+export const DEFAULT_IMAGE_MAX_BYTES = 5 * 1024 * 1024;
+export function resolveImageSanitizationLimits(cfg) {
+    const configured = cfg?.agents?.defaults?.imageMaxDimensionPx;
+    if (typeof configured !== "number" || !Number.isFinite(configured)) {
+        return {};
+    }
+    return { maxDimensionPx: Math.max(1, Math.floor(configured)) };
+}