@poolzin/pool-bot 2026.2.25 → 2026.2.26

package/dist/cron/service/timer.js

@@ -19,6 +19,13 @@ const MIN_REFIRE_GAP_MS = 2_000;
  * from wedging the entire cron lane.
  */
 const DEFAULT_JOB_TIMEOUT_MS = 10 * 60_000; // 10 minutes
+function resolveRunConcurrency(state) {
+    const raw = state.deps.cronConfig?.maxConcurrentRuns;
+    if (typeof raw !== "number" || !Number.isFinite(raw)) {
+        return 1;
+    }
+    return Math.max(1, Math.floor(raw));
+}
 /**
  * Exponential backoff delays (in ms) indexed by consecutive error count.
  * After the last entry the delay stays constant.
@@ -45,6 +52,7 @@ function applyJobResult(state, job, result) {
     job.state.lastStatus = result.status;
     job.state.lastDurationMs = Math.max(0, result.endedAt - result.startedAt);
     job.state.lastError = result.error;
+    job.state.lastDelivered = result.delivered;
     job.updatedAtMs = result.endedAt;
     // Track consecutive errors for backoff / auto-disable.
     if (result.status === "error") {
@@ -187,8 +195,8 @@ export async function onTimer(state) {
                 job: j,
             }));
         });
-        const results = [];
-        for (const { id, job } of dueJobs) {
+        const runDueJob = async (params) => {
+            const { id, job } = params;
             const startedAt = state.deps.nowMs();
             job.state.runningAtMs = startedAt;
             emit(state, { jobId: job.id, action: "started", runAtMs: startedAt });
@@ -219,23 +227,41 @@ export async function onTimer(state) {
                         }
                     })()
                     : await executeJobCore(state, job);
-                results.push({ jobId: id, ...result, startedAt, endedAt: state.deps.nowMs() });
+                return { jobId: id, ...result, startedAt, endedAt: state.deps.nowMs() };
             }
             catch (err) {
                 state.deps.log.warn({ jobId: id, jobName: job.name, timeoutMs: jobTimeoutMs ?? null }, `cron: job failed: ${String(err)}`);
-                results.push({
+                return {
                     jobId: id,
                     status: "error",
                     error: String(err),
                     startedAt,
                     endedAt: state.deps.nowMs(),
-                });
+                };
             }
-        }
-        if (results.length > 0) {
+        };
+        const concurrency = Math.min(resolveRunConcurrency(state), Math.max(1, dueJobs.length));
+        const results = Array.from({ length: dueJobs.length });
+        let cursor = 0;
+        const workers = Array.from({ length: concurrency }, async () => {
+            for (;;) {
+                const index = cursor++;
+                if (index >= dueJobs.length) {
+                    return;
+                }
+                const due = dueJobs[index];
+                if (!due) {
+                    return;
+                }
+                results[index] = await runDueJob(due);
+            }
+        });
+        await Promise.all(workers);
+        const completedResults = results.filter((entry) => entry !== undefined);
+        if (completedResults.length > 0) {
             await locked(state, async () => {
                 await ensureLoaded(state, { forceReload: true, skipRecompute: true });
-                for (const result of results) {
+                for (const result of completedResults) {
                     const job = state.store?.jobs.find((j) => j.id === result.jobId);
                     if (!job) {
                         continue;
@@ -243,6 +269,7 @@ export async function onTimer(state) {
                     const shouldDelete = applyJobResult(state, job, {
                         status: result.status,
                         error: result.error,
+                        delivered: result.delivered,
                         startedAt: result.startedAt,
                         endedAt: result.endedAt,
                     });
@@ -342,18 +369,88 @@ function collectRunnableJobs(state, nowMs, opts) {
     }));
 }
 export async function runMissedJobs(state, opts) {
-    if (!state.store) {
-        return;
-    }
-    const now = state.deps.nowMs();
-    const skipJobIds = opts?.skipJobIds;
-    const missed = collectRunnableJobs(state, now, { skipJobIds, skipAtIfAlreadyRan: true });
-    if (missed.length > 0) {
+    const startupCandidates = await locked(state, async () => {
+        await ensureLoaded(state, { skipRecompute: true });
+        if (!state.store) {
+            return [];
+        }
+        const now = state.deps.nowMs();
+        const skipJobIds = opts?.skipJobIds;
+        const missed = collectRunnableJobs(state, now, { skipJobIds, skipAtIfAlreadyRan: true });
+        if (missed.length === 0) {
+            return [];
+        }
         state.deps.log.info({ count: missed.length, jobIds: missed.map((j) => j.id) }, "cron: running missed jobs after restart");
         for (const job of missed) {
-            await executeJob(state, job, now, { forced: false });
+            job.state.runningAtMs = now;
+            job.state.lastError = undefined;
+        }
+        await persist(state);
+        return missed.map((job) => ({ jobId: job.id, job }));
+    });
+    if (startupCandidates.length === 0) {
+        return;
+    }
+    const outcomes = [];
+    for (const candidate of startupCandidates) {
+        const startedAt = state.deps.nowMs();
+        emit(state, { jobId: candidate.job.id, action: "started", runAtMs: startedAt });
+        try {
+            const result = await executeJobCore(state, candidate.job);
+            outcomes.push({
+                jobId: candidate.jobId,
+                status: result.status,
+                error: result.error,
+                summary: result.summary,
+                delivered: result.delivered,
+                sessionId: result.sessionId,
+                sessionKey: result.sessionKey,
+                model: result.model,
+                provider: result.provider,
+                usage: result.usage,
+                startedAt,
+                endedAt: state.deps.nowMs(),
+            });
+        }
+        catch (err) {
+            outcomes.push({
+                jobId: candidate.jobId,
+                status: "error",
+                error: String(err),
+                startedAt,
+                endedAt: state.deps.nowMs(),
+            });
         }
     }
+    await locked(state, async () => {
+        await ensureLoaded(state, { forceReload: true, skipRecompute: true });
+        if (!state.store) {
+            return;
+        }
+        for (const result of outcomes) {
+            const job = state.store.jobs.find((entry) => entry.id === result.jobId);
+            if (!job) {
+                continue;
+            }
+            const shouldDelete = applyJobResult(state, job, {
+                status: result.status,
+                error: result.error,
+                delivered: result.delivered,
+                startedAt: result.startedAt,
+                endedAt: result.endedAt,
+            });
+            emitJobFinished(state, job, result, result.startedAt);
+            if (shouldDelete) {
+                state.store.jobs = state.store.jobs.filter((entry) => entry.id !== job.id);
+                emit(state, { jobId: job.id, action: "removed" });
+            }
+        }
+        // Preserve any new past-due nextRunAtMs values that became due while
+        // startup catch-up was running. They should execute on a future tick
+        // instead of being silently advanced.
+        recomputeNextRunsForMaintenance(state);
+        await persist(state);
+    });
 }
 export async function runDueJobs(state) {
     if (!state.store) {
@@ -463,6 +560,7 @@ async function executeJobCore(state, job) {
         status: res.status,
         error: res.error,
         summary: res.summary,
+        delivered: res.delivered,
         sessionId: res.sessionId,
         sessionKey: res.sessionKey,
         model: res.model,
@@ -493,6 +591,7 @@ export async function executeJob(state, job, _nowMs, _opts) {
     const shouldDelete = applyJobResult(state, job, {
         status: coreResult.status,
         error: coreResult.error,
+        delivered: coreResult.delivered,
         startedAt,
         endedAt,
     });
@@ -509,6 +608,7 @@ function emitJobFinished(state, job, result, runAtMs) {
         status: result.status,
         error: result.error,
         summary: result.summary,
+        delivered: result.delivered,
         sessionId: result.sessionId,
         sessionKey: result.sessionKey,
         runAtMs,

package/dist/cron/stagger.js

@@ -33,5 +33,7 @@ export function resolveCronStaggerMs(schedule) {
     if (explicit !== undefined) {
         return explicit;
     }
-    return resolveDefaultCronStaggerMs(schedule.expr) ?? 0;
+    const expr = schedule.expr;
+    const cronExpr = typeof expr === "string" ? expr : "";
+    return resolveDefaultCronStaggerMs(cronExpr) ?? 0;
 }

package/dist/discord/api.js

@@ -9,12 +9,14 @@ const DISCORD_API_RETRY_DEFAULTS = {
 };
 function parseDiscordApiErrorPayload(text) {
     const trimmed = text.trim();
-    if (!trimmed.startsWith("{") || !trimmed.endsWith("}"))
+    if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) {
         return null;
+    }
     try {
         const payload = JSON.parse(trimmed);
-        if (payload && typeof payload === "object")
+        if (payload && typeof payload === "object") {
             return payload;
+        }
     }
     catch {
         return null;
@@ -26,24 +28,28 @@ function parseRetryAfterSeconds(text, response) {
     const retryAfter = payload && typeof payload.retry_after === "number" && Number.isFinite(payload.retry_after)
         ? payload.retry_after
         : undefined;
-    if (retryAfter !== undefined)
+    if (retryAfter !== undefined) {
         return retryAfter;
+    }
     const header = response.headers.get("Retry-After");
-    if (!header)
+    if (!header) {
         return undefined;
+    }
     const parsed = Number(header);
     return Number.isFinite(parsed) ? parsed : undefined;
 }
 function formatRetryAfterSeconds(value) {
-    if (value === undefined || !Number.isFinite(value) || value < 0)
+    if (value === undefined || !Number.isFinite(value) || value < 0) {
         return undefined;
+    }
     const rounded = value < 10 ? value.toFixed(1) : Math.round(value).toString();
     return `${rounded}s`;
 }
 function formatDiscordApiErrorText(text) {
     const trimmed = text.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return undefined;
+    }
     const payload = parseDiscordApiErrorPayload(trimmed);
     if (!payload) {
         const looksJson = trimmed.startsWith("{") && trimmed.endsWith("}");

package/dist/discord/draft-chunking.js

@@ -0,0 +1,22 @@
+import { resolveTextChunkLimit } from "../auto-reply/chunk.js";
+import { getChannelDock } from "../channels/dock.js";
+import { normalizeAccountId } from "../routing/session-key.js";
+const DEFAULT_DISCORD_DRAFT_STREAM_MIN = 200;
+const DEFAULT_DISCORD_DRAFT_STREAM_MAX = 800;
+export function resolveDiscordDraftStreamingChunking(cfg, accountId) {
+    const providerChunkLimit = getChannelDock("discord")?.outbound?.textChunkLimit;
+    const textLimit = resolveTextChunkLimit(cfg, "discord", accountId, {
+        fallbackLimit: providerChunkLimit,
+    });
+    const normalizedAccountId = normalizeAccountId(accountId);
+    const draftCfg = cfg?.channels?.discord?.accounts?.[normalizedAccountId]?.draftChunk ??
+        cfg?.channels?.discord?.draftChunk;
+    const maxRequested = Math.max(1, Math.floor(draftCfg?.maxChars ?? DEFAULT_DISCORD_DRAFT_STREAM_MAX));
+    const maxChars = Math.max(1, Math.min(maxRequested, textLimit));
+    const minRequested = Math.max(1, Math.floor(draftCfg?.minChars ?? DEFAULT_DISCORD_DRAFT_STREAM_MIN));
+    const minChars = Math.min(minRequested, maxChars);
+    const breakPreference = draftCfg?.breakPreference === "newline" || draftCfg?.breakPreference === "sentence"
+        ? draftCfg.breakPreference
+        : "paragraph";
+    return { minChars, maxChars, breakPreference };
+}

package/dist/discord/draft-stream.js

@@ -0,0 +1,124 @@
+import { Routes } from "discord-api-types/v10";
+import { createDraftStreamLoop } from "../channels/draft-stream-loop.js";
+/** Discord messages cap at 2000 characters. */
+const DISCORD_STREAM_MAX_CHARS = 2000;
+const DEFAULT_THROTTLE_MS = 1200;
+export function createDiscordDraftStream(params) {
+    const maxChars = Math.min(params.maxChars ?? DISCORD_STREAM_MAX_CHARS, DISCORD_STREAM_MAX_CHARS);
+    const throttleMs = Math.max(250, params.throttleMs ?? DEFAULT_THROTTLE_MS);
+    const minInitialChars = params.minInitialChars;
+    const channelId = params.channelId;
+    const rest = params.rest;
+    const resolveReplyToMessageId = () => typeof params.replyToMessageId === "function"
+        ? params.replyToMessageId()
+        : params.replyToMessageId;
+    let streamMessageId;
+    let lastSentText = "";
+    let stopped = false;
+    let isFinal = false;
+    const sendOrEditStreamMessage = async (text) => {
+        // Allow final flush even if stopped (e.g., after clear()).
+        if (stopped && !isFinal) {
+            return false;
+        }
+        const trimmed = text.trimEnd();
+        if (!trimmed) {
+            return false;
+        }
+        if (trimmed.length > maxChars) {
+            // Discord messages cap at 2000 chars.
+            // Stop streaming once we exceed the cap to avoid repeated API failures.
+            stopped = true;
+            params.warn?.(`discord stream preview stopped (text length ${trimmed.length} > ${maxChars})`);
+            return false;
+        }
+        if (trimmed === lastSentText) {
+            return true;
+        }
+        // Debounce first preview send for better push notification quality.
+        if (streamMessageId === undefined && minInitialChars != null && !isFinal) {
+            if (trimmed.length < minInitialChars) {
+                return false;
+            }
+        }
+        lastSentText = trimmed;
+        try {
+            if (streamMessageId !== undefined) {
+                // Edit existing message
+                await rest.patch(Routes.channelMessage(channelId, streamMessageId), {
+                    body: { content: trimmed },
+                });
+                return true;
+            }
+            // Send new message
+            const replyToMessageId = resolveReplyToMessageId()?.trim();
+            const messageReference = replyToMessageId
+                ? { message_id: replyToMessageId, fail_if_not_exists: false }
+                : undefined;
+            const sent = (await rest.post(Routes.channelMessages(channelId), {
+                body: {
+                    content: trimmed,
+                    ...(messageReference ? { message_reference: messageReference } : {}),
+                },
+            }));
+            const sentMessageId = sent?.id;
+            if (typeof sentMessageId !== "string" || !sentMessageId) {
+                stopped = true;
+                params.warn?.("discord stream preview stopped (missing message id from send)");
+                return false;
+            }
+            streamMessageId = sentMessageId;
+            return true;
+        }
+        catch (err) {
+            stopped = true;
+            params.warn?.(`discord stream preview failed: ${err instanceof Error ? err.message : String(err)}`);
+            return false;
+        }
+    };
+    const loop = createDraftStreamLoop({
+        throttleMs,
+        isStopped: () => stopped,
+        sendOrEditStreamMessage,
+    });
+    const update = (text) => {
+        if (stopped || isFinal) {
+            return;
+        }
+        loop.update(text);
+    };
+    const stop = async () => {
+        isFinal = true;
+        await loop.flush();
+    };
+    const clear = async () => {
+        stopped = true;
+        loop.stop();
+        await loop.waitForInFlight();
+        const messageId = streamMessageId;
+        streamMessageId = undefined;
+        if (typeof messageId !== "string") {
+            return;
+        }
+        try {
+            await rest.delete(Routes.channelMessage(channelId, messageId));
+        }
+        catch (err) {
+            params.warn?.(`discord stream preview cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    };
+    const forceNewMessage = () => {
+        streamMessageId = undefined;
+        lastSentText = "";
+        loop.resetPending();
+    };
+    params.log?.(`discord stream preview ready (maxChars=${maxChars}, throttleMs=${throttleMs})`);
+    return {
+        update,
+        flush: loop.flush,
+        messageId: () => streamMessageId,
+        clear,
+        stop,
+        forceNewMessage,
+    };
+}

package/dist/discord/monitor/agent-components.js

@@ -283,7 +283,7 @@ async function ensureDmComponentAuthorized(params) {
     if (dmPolicy === "open") {
         return true;
     }
-    const storeAllowFrom = await readChannelAllowFromStore("discord").catch(() => []);
+    const storeAllowFrom = dmPolicy === "allowlist" ? await readChannelAllowFromStore("discord").catch(() => []) : [];
     const effectiveAllowFrom = [...(ctx.allowFrom ?? []), ...storeAllowFrom];
     const allowList = normalizeDiscordAllowList(effectiveAllowFrom, ["discord:", "user:", "pk:"]);
     const allowMatch = allowList

package/dist/discord/monitor/commands.js

@@ -0,0 +1,5 @@
+export function resolveDiscordSlashCommandConfig(raw) {
+    return {
+        ephemeral: raw?.ephemeral !== false,
+    };
+}

package/dist/discord/monitor/gateway-plugin.js

@@ -8,7 +8,8 @@ export function resolveDiscordGatewayIntents(intentsConfig) {
         GatewayIntents.MessageContent |
         GatewayIntents.DirectMessages |
         GatewayIntents.GuildMessageReactions |
-        GatewayIntents.DirectMessageReactions;
+        GatewayIntents.DirectMessageReactions |
+        GatewayIntents.GuildVoiceStates;
     if (intentsConfig?.presence) {
         intents |= GatewayIntents.GuildPresences;
     }

package/dist/discord/monitor/listeners.js

@@ -28,6 +28,27 @@ function logSlowDiscordListener(params) {
         consoleMessage: message,
     });
 }
+async function runDiscordListenerWithSlowLog(params) {
+    const startedAt = Date.now();
+    try {
+        await params.run();
+    }
+    catch (err) {
+        if (params.onError) {
+            params.onError(err);
+            return;
+        }
+        throw err;
+    }
+    finally {
+        logSlowDiscordListener({
+            logger: params.logger,
+            listener: params.listener,
+            event: params.event,
+            durationMs: Date.now() - startedAt,
+        });
+    }
+}
 export function registerDiscordListener(listeners, listener) {
     if (listeners.some((existing) => existing.constructor === listener.constructor)) {
         return false;
@@ -44,20 +65,15 @@ export class DiscordMessageListener extends MessageCreateListener {
         this.logger = logger;
     }
     async handle(data, client) {
-        const startedAt = Date.now();
-        const task = Promise.resolve(this.handler(data, client));
-        void task
-            .catch((err) => {
-            const logger = this.logger ?? discordEventQueueLog;
-            logger.error(danger(`discord handler failed: ${String(err)}`));
-        })
-            .finally(() => {
-            logSlowDiscordListener({
-                logger: this.logger,
-                listener: this.constructor.name,
-                event: this.type,
-                durationMs: Date.now() - startedAt,
-            });
+        await runDiscordListenerWithSlowLog({
+            logger: this.logger,
+            listener: this.constructor.name,
+            event: this.type,
+            run: () => this.handler(data, client),
+            onError: (err) => {
+                const logger = this.logger ?? discordEventQueueLog;
+                logger.error(danger(`discord handler failed: ${String(err)}`));
+            },
         });
     }
 }
@@ -96,9 +112,11 @@ export class DiscordReactionRemoveListener extends MessageReactionRemoveListener
     }
 }
 async function runDiscordReactionHandler(params) {
-    const startedAt = Date.now();
-    try {
-        await handleDiscordReactionEvent({
+    await runDiscordListenerWithSlowLog({
+        logger: params.handlerParams.logger,
+        listener: params.listener,
+        event: params.event,
+        run: () => handleDiscordReactionEvent({
             data: params.data,
             client: params.client,
             action: params.action,
@@ -107,16 +125,8 @@ async function runDiscordReactionHandler(params) {
             botUserId: params.handlerParams.botUserId,
             guildEntries: params.handlerParams.guildEntries,
             logger: params.handlerParams.logger,
-        });
-    }
-    finally {
-        logSlowDiscordListener({
-            logger: params.handlerParams.logger,
-            listener: params.listener,
-            event: params.event,
-            durationMs: Date.now() - startedAt,
-        });
-    }
+        }),
+    });
 }
 async function handleDiscordReactionEvent(params) {
     try {

package/dist/discord/monitor/message-handler.js

@@ -3,7 +3,7 @@ import { createInboundDebouncer, resolveInboundDebounceMs, } from "../../auto-re
 import { danger } from "../../globals.js";
 import { preflightDiscordMessage } from "./message-handler.preflight.js";
 import { processDiscordMessage } from "./message-handler.process.js";
-import { resolveDiscordMessageChannelId, resolveDiscordMessageText } from "./message-utils.js";
+import { hasDiscordMessageStickers, resolveDiscordMessageChannelId, resolveDiscordMessageText, } from "./message-utils.js";
 export function createDiscordMessageHandler(params) {
     const groupPolicy = params.discordConfig?.groupPolicy ?? "open";
     const ackReactionScope = params.cfg.messages?.ackReactionScope ?? "group-mentions";
@@ -33,6 +33,9 @@ export function createDiscordMessageHandler(params) {
             if (message.attachments && message.attachments.length > 0) {
                 return false;
             }
+            if (hasDiscordMessageStickers(message)) {
+                return false;
+            }
             const baseText = resolveDiscordMessageText(message, { includeForwarded: false });
             if (!baseText.trim()) {
                 return false;