@poolzin/pool-bot 2026.2.24 → 2026.2.26

package/dist/config/zod-schema.session.js

@@ -4,6 +4,7 @@ import { parseDurationMs } from "../cli/parse-duration.js";
 import { ElevatedAllowFromSchema } from "./zod-schema.agent-runtime.js";
 import { createAllowDenyChannelRulesSchema } from "./zod-schema.allowdeny.js";
 import { GroupChatSchema, InboundDebounceSchema, NativeCommandsSettingSchema, QueueSchema, TtsConfigSchema, } from "./zod-schema.core.js";
+import { sensitive } from "./zod-schema.sensitive.js";
 const SessionResetConfigSchema = z
     .object({
     mode: z.union([z.literal("daily"), z.literal("idle")]).optional(),
@@ -56,6 +57,13 @@ export const SessionSchema = z
     })
         .strict()
         .optional(),
+    threadBindings: z
+        .object({
+        enabled: z.boolean().optional(),
+        ttlHours: z.number().nonnegative().optional(),
+    })
+        .strict()
+        .optional(),
     maintenance: z
         .object({
         mode: z.enum(["enforce", "warn"]).optional(),
@@ -106,6 +114,35 @@ export const MessagesSchema = z
     ackReaction: z.string().optional(),
     ackReactionScope: z.enum(["group-mentions", "group-all", "direct", "all"]).optional(),
     removeAckAfterReply: z.boolean().optional(),
+    statusReactions: z
+        .object({
+        enabled: z.boolean().optional(),
+        emojis: z
+            .object({
+            thinking: z.string().optional(),
+            tool: z.string().optional(),
+            coding: z.string().optional(),
+            web: z.string().optional(),
+            done: z.string().optional(),
+            error: z.string().optional(),
+            stallSoft: z.string().optional(),
+            stallHard: z.string().optional(),
+        })
+            .strict()
+            .optional(),
+        timing: z
+            .object({
+            debounceMs: z.number().int().min(0).optional(),
+            stallSoftMs: z.number().int().min(0).optional(),
+            stallHardMs: z.number().int().min(0).optional(),
+            doneHoldMs: z.number().int().min(0).optional(),
+            errorHoldMs: z.number().int().min(0).optional(),
+        })
+            .strict()
+            .optional(),
+    })
+        .strict()
+        .optional(),
     suppressToolErrors: z.boolean().optional(),
     tts: TtsConfigSchema,
 })
@@ -120,11 +157,13 @@ export const CommandsSchema = z
     bashForegroundMs: z.number().int().min(0).max(30_000).optional(),
     config: z.boolean().optional(),
     debug: z.boolean().optional(),
-    restart: z.boolean().optional(),
+    restart: z.boolean().optional().default(true),
     useAccessGroups: z.boolean().optional(),
     ownerAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+    ownerDisplay: z.enum(["raw", "hash"]).optional().default("raw"),
+    ownerDisplaySecret: z.string().optional().register(sensitive),
     allowFrom: ElevatedAllowFromSchema.optional(),
 })
     .strict()
     .optional()
-    .default({ native: "auto", nativeSkills: "auto" });
+    .default(() => ({ native: "auto", nativeSkills: "auto", restart: true, ownerDisplay: "raw" }));

package/dist/cron/run-log.js

@@ -93,6 +93,9 @@ export async function readCronRunLogEntries(filePath, opts) {
                     }
                     : undefined,
             };
+            if (typeof obj.delivered === "boolean") {
+                entry.delivered = obj.delivered;
+            }
             if (typeof obj.sessionId === "string" && obj.sessionId.trim().length > 0) {
                 entry.sessionId = obj.sessionId;
             }

package/dist/cron/schedule.js

@@ -35,7 +35,11 @@ export function computeNextRunAtMs(schedule, nowMs) {
         const steps = Math.max(1, Math.floor((elapsed + everyMs - 1) / everyMs));
         return anchor + steps * everyMs;
     }
-    const expr = schedule.expr.trim();
+    const exprSource = schedule.expr;
+    if (typeof exprSource !== "string") {
+        throw new Error("invalid cron schedule: expr is required");
+    }
+    const expr = exprSource.trim();
     if (!expr) {
         return undefined;
     }
@@ -43,17 +47,24 @@ export function computeNextRunAtMs(schedule, nowMs) {
         timezone: resolveCronTimezone(schedule.tz),
         catch: false,
     });
-    // Cron operates at second granularity, so floor nowMs to the start of the
-    // current second.  This prevents the lookback from landing inside a matching
-    // second — if nowMs is e.g. 12:00:00.500 and the pattern fires at second 0,
-    // a 1ms lookback (12:00:00.499) is still *within* that second, causing
-    // croner to skip ahead to the next occurrence (e.g. the following day).
-    // Flooring first ensures the lookback always falls in the *previous* second.
-    const nowSecondMs = Math.floor(nowMs / 1000) * 1000;
-    const next = cron.nextRun(new Date(nowSecondMs - 1));
+    const next = cron.nextRun(new Date(nowMs));
     if (!next) {
         return undefined;
     }
     const nextMs = next.getTime();
-    return Number.isFinite(nextMs) && nextMs >= nowSecondMs ? nextMs : undefined;
+    if (!Number.isFinite(nextMs)) {
+        return undefined;
+    }
+    if (nextMs > nowMs) {
+        return nextMs;
+    }
+    // Guard against same-second rescheduling loops: if croner returns
+    // "now" (or an earlier instant), retry from the next whole second.
+    const nextSecondMs = Math.floor(nowMs / 1000) * 1000 + 1000;
+    const retry = cron.nextRun(new Date(nextSecondMs));
+    if (!retry) {
+        return undefined;
+    }
+    const retryMs = retry.getTime();
+    return Number.isFinite(retryMs) && retryMs > nowMs ? retryMs : undefined;
 }

package/dist/cron/service/ops.js

@@ -1,22 +1,40 @@
-import { applyJobPatch, computeJobNextRunAtMs, createJob, findJobOrThrow, isJobDue, nextWakeAtMs, recomputeNextRuns, } from "./jobs.js";
+import { applyJobPatch, computeJobNextRunAtMs, createJob, findJobOrThrow, isJobDue, nextWakeAtMs, recomputeNextRuns, recomputeNextRunsForMaintenance, } from "./jobs.js";
 import { locked } from "./locked.js";
 import { ensureLoaded, persist, warnIfDisabled } from "./store.js";
 import { armTimer, emit, executeJob, runMissedJobs, stopTimer, wake } from "./timer.js";
+async function ensureLoadedForRead(state) {
+    await ensureLoaded(state, { skipRecompute: true });
+    if (!state.store) {
+        return;
+    }
+    // Use the maintenance-only version so that read-only operations never
+    // advance a past-due nextRunAtMs without executing the job (#16156).
+    const changed = recomputeNextRunsForMaintenance(state);
+    if (changed) {
+        await persist(state);
+    }
+}
 export async function start(state) {
+    if (!state.deps.cronEnabled) {
+        state.deps.log.info({ enabled: false }, "cron: disabled");
+        return;
+    }
+    const startupInterruptedJobIds = new Set();
     await locked(state, async () => {
-        if (!state.deps.cronEnabled) {
-            state.deps.log.info({ enabled: false }, "cron: disabled");
-            return;
-        }
         await ensureLoaded(state, { skipRecompute: true });
         const jobs = state.store?.jobs ?? [];
         for (const job of jobs) {
             if (typeof job.state.runningAtMs === "number") {
                 state.deps.log.warn({ jobId: job.id, runningAtMs: job.state.runningAtMs }, "cron: clearing stale running marker on startup");
                 job.state.runningAtMs = undefined;
+                startupInterruptedJobIds.add(job.id);
             }
         }
-        await runMissedJobs(state);
+        await persist(state);
+    });
+    await runMissedJobs(state, { skipJobIds: startupInterruptedJobIds });
+    await locked(state, async () => {
+        await ensureLoaded(state, { forceReload: true, skipRecompute: true });
         recomputeNextRuns(state);
         await persist(state);
         armTimer(state);
@@ -32,13 +50,7 @@ export function stop(state) {
 }
 export async function status(state) {
     return await locked(state, async () => {
-        await ensureLoaded(state, { skipRecompute: true });
-        if (state.store) {
-            const changed = recomputeNextRuns(state);
-            if (changed) {
-                await persist(state);
-            }
-        }
+        await ensureLoadedForRead(state);
         return {
             enabled: state.deps.cronEnabled,
             storePath: state.deps.storePath,
@@ -49,13 +61,7 @@ export async function status(state) {
 }
 export async function list(state, opts) {
     return await locked(state, async () => {
-        await ensureLoaded(state, { skipRecompute: true });
-        if (state.store) {
-            const changed = recomputeNextRuns(state);
-            if (changed) {
-                await persist(state);
-            }
-        }
+        await ensureLoadedForRead(state);
         const includeDisabled = opts?.includeDisabled === true;
         const jobs = (state.store?.jobs ?? []).filter((j) => includeDisabled || j.enabled);
         return jobs.toSorted((a, b) => (a.state.nextRunAtMs ?? 0) - (b.state.nextRunAtMs ?? 0));
@@ -90,7 +96,7 @@ export async function add(state, input) {
 export async function update(state, id, patch) {
     return await locked(state, async () => {
         warnIfDisabled(state, "update");
-        await ensureLoaded(state);
+        await ensureLoaded(state, { skipRecompute: true });
         const job = findJobOrThrow(state, id);
         const now = state.deps.nowMs();
         applyJobPatch(job, patch);
@@ -121,6 +127,14 @@ export async function update(state, id, patch) {
                 job.state.runningAtMs = undefined;
             }
         }
+        else if (job.enabled) {
+            // Non-schedule edits should not mutate other jobs, but still repair a
+            // missing/corrupt nextRunAtMs for the updated job.
+            const nextRun = job.state.nextRunAtMs;
+            if (typeof nextRun !== "number" || !Number.isFinite(nextRun)) {
+                job.state.nextRunAtMs = computeJobNextRunAtMs(job, now);
+            }
+        }
         await persist(state);
         armTimer(state);
         emit(state, {

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/daemon/cmd-argv.js

@@ -0,0 +1,21 @@
+import { splitArgsPreservingQuotes } from "./arg-split.js";
+import { assertNoCmdLineBreak } from "./cmd-set.js";
+export function quoteCmdScriptArg(value) {
+    assertNoCmdLineBreak(value, "Command argument");
+    if (!value) {
+        return '""';
+    }
+    const escaped = value.replace(/"/g, '\\"').replace(/%/g, "%%").replace(/!/g, "^!");
+    if (!/[ \t"&|<>^()%!]/g.test(value)) {
+        return escaped;
+    }
+    return `"${escaped}"`;
+}
+export function unescapeCmdScriptArg(value) {
+    return value.replace(/\^!/g, "!").replace(/%%/g, "%");
+}
+export function parseCmdScriptCommandLine(value) {
+    // Script renderer escapes quotes (`\"`) and cmd expansions (`%%`, `^!`).
+    // Keep all other backslashes literal so Windows drive/UNC paths survive.
+    return splitArgsPreservingQuotes(value, { escapeMode: "backslash-quote-only" }).map(unescapeCmdScriptArg);
+}

package/dist/daemon/cmd-set.js

@@ -0,0 +1,58 @@
+export function assertNoCmdLineBreak(value, field) {
+    if (/[\r\n]/.test(value)) {
+        throw new Error(`${field} cannot contain CR or LF in Windows task scripts.`);
+    }
+}
+function escapeCmdSetAssignmentComponent(value) {
+    return value.replace(/\^/g, "^^").replace(/%/g, "%%").replace(/!/g, "^!").replace(/"/g, '^"');
+}
+function unescapeCmdSetAssignmentComponent(value) {
+    let out = "";
+    for (let i = 0; i < value.length; i += 1) {
+        const ch = value[i];
+        const next = value[i + 1];
+        if (ch === "^" && (next === "^" || next === '"' || next === "!")) {
+            out += next;
+            i += 1;
+            continue;
+        }
+        if (ch === "%" && next === "%") {
+            out += "%";
+            i += 1;
+            continue;
+        }
+        out += ch;
+    }
+    return out;
+}
+export function parseCmdSetAssignment(line) {
+    const raw = line.trim();
+    if (!raw) {
+        return null;
+    }
+    const quoted = raw.startsWith('"') && raw.endsWith('"') && raw.length >= 2;
+    const assignment = quoted ? raw.slice(1, -1) : raw;
+    const index = assignment.indexOf("=");
+    if (index <= 0) {
+        return null;
+    }
+    const key = assignment.slice(0, index).trim();
+    const value = assignment.slice(index + 1).trim();
+    if (!key) {
+        return null;
+    }
+    if (!quoted) {
+        return { key, value };
+    }
+    return {
+        key: unescapeCmdSetAssignmentComponent(key),
+        value: unescapeCmdSetAssignmentComponent(value),
+    };
+}
+export function renderCmdSetAssignment(key, value) {
+    assertNoCmdLineBreak(key, "Environment variable name");
+    assertNoCmdLineBreak(value, "Environment variable value");
+    const escapedKey = escapeCmdSetAssignmentComponent(key);
+    const escapedValue = escapeCmdSetAssignmentComponent(value);
+    return `set "${escapedKey}=${escapedValue}"`;
+}

package/dist/daemon/service-types.js

@@ -0,0 +1 @@
+export {};

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 };
+}