@poolzin/pool-bot 2026.2.17 → 2026.2.18

package/dist/cron/isolated-agent/skills-snapshot.js

@@ -0,0 +1,26 @@
+import { resolveAgentSkillsFilter } from "../../agents/agent-scope.js";
+import { buildWorkspaceSkillSnapshot } from "../../agents/skills.js";
+import { matchesSkillFilter } from "../../agents/skills/filter.js";
+import { getSkillsSnapshotVersion } from "../../agents/skills/refresh.js";
+import { getRemoteSkillEligibility } from "../../infra/skills-remote.js";
+export function resolveCronSkillsSnapshot(params) {
+    if (params.isFastTestEnv) {
+        // Fast unit-test mode skips filesystem scans and snapshot refresh writes.
+        return params.existingSnapshot ?? { prompt: "", skills: [] };
+    }
+    const snapshotVersion = getSkillsSnapshotVersion(params.workspaceDir);
+    const skillFilter = resolveAgentSkillsFilter(params.config, params.agentId);
+    const existingSnapshot = params.existingSnapshot;
+    const shouldRefresh = !existingSnapshot ||
+        existingSnapshot.version !== snapshotVersion ||
+        !matchesSkillFilter(existingSnapshot.skillFilter, skillFilter);
+    if (!shouldRefresh) {
+        return existingSnapshot;
+    }
+    return buildWorkspaceSkillSnapshot(params.workspaceDir, {
+        config: params.config,
+        skillFilter,
+        eligibility: { remote: getRemoteSkillEligibility() },
+        snapshotVersion,
+    });
+}

package/dist/cron/isolated-agent/subagent-followup.js

@@ -0,0 +1,127 @@
+import { countActiveDescendantRuns, listDescendantRunsForRequester, } from "../../agents/subagent-registry.js";
+import { readLatestAssistantReply } from "../../agents/tools/agent-step.js";
+import { SILENT_REPLY_TOKEN } from "../../auto-reply/tokens.js";
+const CRON_SUBAGENT_WAIT_POLL_MS = 500;
+const CRON_SUBAGENT_WAIT_MIN_MS = 30_000;
+const CRON_SUBAGENT_FINAL_REPLY_GRACE_MS = 5_000;
+export function isLikelyInterimCronMessage(value) {
+    const text = value.trim();
+    if (!text) {
+        return true;
+    }
+    const normalized = text.toLowerCase().replace(/\s+/g, " ");
+    const words = normalized.split(" ").filter(Boolean).length;
+    const interimHints = [
+        "on it",
+        "pulling everything together",
+        "give me a few",
+        "give me a few min",
+        "few minutes",
+        "let me compile",
+        "i'll gather",
+        "i will gather",
+        "working on it",
+        "retrying now",
+        "should be about",
+        "should have your summary",
+        "subagent spawned",
+        "spawned a subagent",
+        "it'll auto-announce when done",
+        "it will auto-announce when done",
+        "auto-announce when done",
+        "both subagents are running",
+        "wait for them to report back",
+    ];
+    return words <= 45 && interimHints.some((hint) => normalized.includes(hint));
+}
+export function expectsSubagentFollowup(value) {
+    const normalized = value.trim().toLowerCase().replace(/\s+/g, " ");
+    if (!normalized) {
+        return false;
+    }
+    const hints = [
+        "subagent spawned",
+        "spawned a subagent",
+        "auto-announce when done",
+        "both subagents are running",
+        "wait for them to report back",
+    ];
+    return hints.some((hint) => normalized.includes(hint));
+}
+export async function readDescendantSubagentFallbackReply(params) {
+    const descendants = listDescendantRunsForRequester(params.sessionKey)
+        .filter((entry) => typeof entry.endedAt === "number" &&
+        entry.endedAt >= params.runStartedAt &&
+        entry.childSessionKey.trim().length > 0)
+        .toSorted((a, b) => (a.endedAt ?? 0) - (b.endedAt ?? 0));
+    if (descendants.length === 0) {
+        return undefined;
+    }
+    const latestByChild = new Map();
+    for (const entry of descendants) {
+        const childKey = entry.childSessionKey.trim();
+        if (!childKey) {
+            continue;
+        }
+        const current = latestByChild.get(childKey);
+        if (!current || (entry.endedAt ?? 0) >= (current.endedAt ?? 0)) {
+            latestByChild.set(childKey, entry);
+        }
+    }
+    const replies = [];
+    const latestRuns = [...latestByChild.values()]
+        .toSorted((a, b) => (a.endedAt ?? 0) - (b.endedAt ?? 0))
+        .slice(-4);
+    for (const entry of latestRuns) {
+        const reply = (await readLatestAssistantReply({ sessionKey: entry.childSessionKey }))?.trim();
+        if (!reply || reply.toUpperCase() === SILENT_REPLY_TOKEN.toUpperCase()) {
+            continue;
+        }
+        replies.push(reply);
+    }
+    if (replies.length === 0) {
+        return undefined;
+    }
+    if (replies.length === 1) {
+        return replies[0];
+    }
+    return replies.join("\n\n");
+}
+export async function waitForDescendantSubagentSummary(params) {
+    const initialReply = params.initialReply?.trim();
+    const deadline = Date.now() + Math.max(CRON_SUBAGENT_WAIT_MIN_MS, Math.floor(params.timeoutMs));
+    let sawActiveDescendants = params.observedActiveDescendants === true;
+    let drainedAtMs;
+    while (Date.now() < deadline) {
+        const activeDescendants = countActiveDescendantRuns(params.sessionKey);
+        if (activeDescendants > 0) {
+            sawActiveDescendants = true;
+            drainedAtMs = undefined;
+            await new Promise((resolve) => setTimeout(resolve, CRON_SUBAGENT_WAIT_POLL_MS));
+            continue;
+        }
+        if (!sawActiveDescendants) {
+            return initialReply;
+        }
+        if (!drainedAtMs) {
+            drainedAtMs = Date.now();
+        }
+        const latest = (await readLatestAssistantReply({ sessionKey: params.sessionKey }))?.trim();
+        if (latest &&
+            latest.toUpperCase() !== SILENT_REPLY_TOKEN.toUpperCase() &&
+            (latest !== initialReply || !isLikelyInterimCronMessage(latest))) {
+            return latest;
+        }
+        if (Date.now() - drainedAtMs >= CRON_SUBAGENT_FINAL_REPLY_GRACE_MS) {
+            return undefined;
+        }
+        await new Promise((resolve) => setTimeout(resolve, CRON_SUBAGENT_WAIT_POLL_MS));
+    }
+    const latest = (await readLatestAssistantReply({ sessionKey: params.sessionKey }))?.trim();
+    if (latest &&
+        latest.toUpperCase() !== SILENT_REPLY_TOKEN.toUpperCase() &&
+        (latest !== initialReply || !isLikelyInterimCronMessage(latest))) {
+        return latest;
+    }
+    return undefined;
+}

package/dist/cron/isolated-agent.mocks.js

@@ -0,0 +1,12 @@
+import { vi } from "vitest";
+vi.mock("../agents/pi-embedded.js", () => ({
+    abortEmbeddedPiRun: vi.fn().mockReturnValue(false),
+    runEmbeddedPiAgent: vi.fn(),
+    resolveEmbeddedSessionLane: (key) => `session:${key.trim() || "main"}`,
+}));
+vi.mock("../agents/model-catalog.js", () => ({
+    loadModelCatalog: vi.fn(),
+}));
+vi.mock("../agents/subagent-announce.js", () => ({
+    runSubagentAnnounceFlow: vi.fn(),
+}));

package/dist/cron/isolated-agent.test-setup.js

@@ -0,0 +1,22 @@
+import { vi } from "vitest";
+import { loadModelCatalog } from "../agents/model-catalog.js";
+import { runEmbeddedPiAgent } from "../agents/pi-embedded.js";
+import { runSubagentAnnounceFlow } from "../agents/subagent-announce.js";
+import { telegramOutbound } from "../channels/plugins/outbound/telegram.js";
+import { setActivePluginRegistry } from "../plugins/runtime.js";
+import { createOutboundTestPlugin, createTestRegistry } from "../test-utils/channel-plugins.js";
+export function setupIsolatedAgentTurnMocks(params) {
+    if (params?.fast) {
+        vi.stubEnv("POOLBOT_TEST_FAST", "1");
+    }
+    vi.mocked(runEmbeddedPiAgent).mockReset();
+    vi.mocked(loadModelCatalog).mockResolvedValue([]);
+    vi.mocked(runSubagentAnnounceFlow).mockReset().mockResolvedValue(true);
+    setActivePluginRegistry(createTestRegistry([
+        {
+            pluginId: "telegram",
+            plugin: createOutboundTestPlugin({ id: "telegram", outbound: telegramOutbound }),
+            source: "test",
+        },
+    ]));
+}

package/dist/cron/legacy-delivery.js

@@ -0,0 +1,43 @@
+export function hasLegacyDeliveryHints(payload) {
+    if (typeof payload.deliver === "boolean") {
+        return true;
+    }
+    if (typeof payload.bestEffortDeliver === "boolean") {
+        return true;
+    }
+    if (typeof payload.to === "string" && payload.to.trim()) {
+        return true;
+    }
+    return false;
+}
+export function buildDeliveryFromLegacyPayload(payload) {
+    const deliver = payload.deliver;
+    const mode = deliver === false ? "none" : "announce";
+    const channelRaw = typeof payload.channel === "string" ? payload.channel.trim().toLowerCase() : "";
+    const toRaw = typeof payload.to === "string" ? payload.to.trim() : "";
+    const next = { mode };
+    if (channelRaw) {
+        next.channel = channelRaw;
+    }
+    if (toRaw) {
+        next.to = toRaw;
+    }
+    if (typeof payload.bestEffortDeliver === "boolean") {
+        next.bestEffort = payload.bestEffortDeliver;
+    }
+    return next;
+}
+export function stripLegacyDeliveryFields(payload) {
+    if ("deliver" in payload) {
+        delete payload.deliver;
+    }
+    if ("channel" in payload) {
+        delete payload.channel;
+    }
+    if ("to" in payload) {
+        delete payload.to;
+    }
+    if ("bestEffortDeliver" in payload) {
+        delete payload.bestEffortDeliver;
+    }
+}

package/dist/cron/webhook-url.js

@@ -0,0 +1,22 @@
+function isAllowedWebhookProtocol(protocol) {
+    return protocol === "http:" || protocol === "https:";
+}
+export function normalizeHttpWebhookUrl(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return null;
+    }
+    try {
+        const parsed = new URL(trimmed);
+        if (!isAllowedWebhookProtocol(parsed.protocol)) {
+            return null;
+        }
+        return trimmed;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/daemon/arg-split.js

@@ -0,0 +1,40 @@
+export function splitArgsPreservingQuotes(value, options) {
+    const args = [];
+    let current = "";
+    let inQuotes = false;
+    const escapeMode = options?.escapeMode ?? "none";
+    for (let i = 0; i < value.length; i++) {
+        const char = value[i];
+        if (escapeMode === "backslash" && char === "\\") {
+            if (i + 1 < value.length) {
+                current += value[i + 1];
+                i++;
+            }
+            continue;
+        }
+        if (escapeMode === "backslash-quote-only" &&
+            char === "\\" &&
+            i + 1 < value.length &&
+            value[i + 1] === '"') {
+            current += '"';
+            i++;
+            continue;
+        }
+        if (char === '"') {
+            inQuotes = !inQuotes;
+            continue;
+        }
+        if (!inQuotes && /\s/.test(char)) {
+            if (current) {
+                args.push(current);
+                current = "";
+            }
+            continue;
+        }
+        current += char;
+    }
+    if (current) {
+        args.push(current);
+    }
+    return args;
+}

package/dist/daemon/exec-file.js

@@ -0,0 +1,23 @@
+import { execFile } from "node:child_process";
+export async function execFileUtf8(command, args, options = {}) {
+    return await new Promise((resolve) => {
+        execFile(command, args, { ...options, encoding: "utf8" }, (error, stdout, stderr) => {
+            if (!error) {
+                resolve({
+                    stdout: String(stdout ?? ""),
+                    stderr: String(stderr ?? ""),
+                    code: 0,
+                });
+                return;
+            }
+            const e = error;
+            const stderrText = String(stderr ?? "");
+            resolve({
+                stdout: String(stdout ?? ""),
+                stderr: stderrText ||
+                    (typeof e.message === "string" ? e.message : typeof error === "string" ? error : ""),
+                code: typeof e.code === "number" ? e.code : 1,
+            });
+        });
+    });
+}

package/dist/daemon/output.js

@@ -0,0 +1,6 @@
+import { colorize, isRich, theme } from "../terminal/theme.js";
+export const toPosixPath = (value) => value.replace(/\\/g, "/");
+export function formatLine(label, value) {
+    const rich = isRich();
+    return `${colorize(rich, theme.muted, `${label}:`)} ${colorize(rich, theme.command, value)}`;
+}

package/dist/daemon/runtime-format.js

@@ -0,0 +1,31 @@
+import { formatRuntimeStatusWithDetails } from "../infra/runtime-status.js";
+export function formatRuntimeStatus(runtime) {
+    if (!runtime) {
+        return null;
+    }
+    const details = [];
+    if (runtime.subState) {
+        details.push(`sub ${runtime.subState}`);
+    }
+    if (runtime.lastExitStatus !== undefined) {
+        details.push(`last exit ${runtime.lastExitStatus}`);
+    }
+    if (runtime.lastExitReason) {
+        details.push(`reason ${runtime.lastExitReason}`);
+    }
+    if (runtime.lastRunResult) {
+        details.push(`last run ${runtime.lastRunResult}`);
+    }
+    if (runtime.lastRunTime) {
+        details.push(`last run time ${runtime.lastRunTime}`);
+    }
+    if (runtime.detail) {
+        details.push(runtime.detail);
+    }
+    return formatRuntimeStatusWithDetails({
+        status: runtime.status,
+        pid: runtime.pid,
+        state: runtime.state,
+        details,
+    });
+}

package/dist/daemon/schtasks-exec.js

@@ -0,0 +1,4 @@
+import { execFileUtf8 } from "./exec-file.js";
+export async function execSchtasks(args) {
+    return await execFileUtf8("schtasks", args, { windowsHide: true });
+}

package/dist/daemon/service-audit.js

@@ -18,6 +18,7 @@ export const SERVICE_AUDIT_CODES = {
     systemdAfterNetworkOnline: "systemd-after-network-online",
     systemdRestartSec: "systemd-restart-sec",
     systemdWantsNetworkOnline: "systemd-wants-network-online",
+    gatewayTokenDrift: "gateway-token-drift",
 };
 export function needsNodeRuntimeMigration(issues) {
     return issues.some((issue) => issue.code === SERVICE_AUDIT_CODES.gatewayRuntimeBun ||
@@ -254,6 +255,27 @@ async function auditGatewayRuntime(env, command, issues, platform) {
         }
     }
 }
+/**
+ * Check if the service's embedded token differs from the config file token.
+ * Returns an issue if drift is detected (service will use old token after restart).
+ */
+export function checkTokenDrift(params) {
+    const { serviceToken, configToken } = params;
+    // No drift if both are undefined/empty
+    if (!serviceToken && !configToken) {
+        return null;
+    }
+    // Drift: config has token, service has different or no token
+    if (configToken && serviceToken !== configToken) {
+        return {
+            code: SERVICE_AUDIT_CODES.gatewayTokenDrift,
+            message: "Config token differs from service token. The daemon will use the old token after restart.",
+            detail: "Run `poolbot gateway install --force` to sync the token.",
+            level: "recommended",
+        };
+    }
+    return null;
+}
 export async function auditGatewayServiceConfig(params) {
     const issues = [];
     const platform = params.platform ?? process.platform;

package/dist/discord/client.js

@@ -0,0 +1,41 @@
+import { RequestClient } from "@buape/carbon";
+import { loadConfig } from "../config/config.js";
+import { createDiscordRetryRunner } from "../infra/retry-policy.js";
+import { resolveDiscordAccount } from "./accounts.js";
+import { normalizeDiscordToken } from "./token.js";
+function resolveToken(params) {
+    const explicit = normalizeDiscordToken(params.explicit);
+    if (explicit) {
+        return explicit;
+    }
+    const fallback = normalizeDiscordToken(params.fallbackToken);
+    if (!fallback) {
+        throw new Error(`Discord bot token missing for account "${params.accountId}" (set discord.accounts.${params.accountId}.token or DISCORD_BOT_TOKEN for default).`);
+    }
+    return fallback;
+}
+function resolveRest(token, rest) {
+    return rest ?? new RequestClient(token);
+}
+export function createDiscordRestClient(opts, cfg = loadConfig()) {
+    const account = resolveDiscordAccount({ cfg, accountId: opts.accountId });
+    const token = resolveToken({
+        explicit: opts.token,
+        accountId: account.accountId,
+        fallbackToken: account.token,
+    });
+    const rest = resolveRest(token, opts.rest);
+    return { token, rest, account };
+}
+export function createDiscordClient(opts, cfg = loadConfig()) {
+    const { token, rest, account } = createDiscordRestClient(opts, cfg);
+    const request = createDiscordRetryRunner({
+        retry: opts.retry,
+        configRetry: account.config.retry,
+        verbose: opts.verbose,
+    });
+    return { token, rest, request };
+}
+export function resolveDiscordRest(opts) {
+    return createDiscordRestClient(opts).rest;
+}

package/dist/discord/components-registry.js

@@ -0,0 +1,57 @@
+const DEFAULT_COMPONENT_TTL_MS = 30 * 60 * 1000;
+const componentEntries = new Map();
+const modalEntries = new Map();
+function isExpired(entry, now) {
+    return typeof entry.expiresAt === "number" && entry.expiresAt <= now;
+}
+function normalizeEntryTimestamps(entry, now, ttlMs) {
+    const createdAt = entry.createdAt ?? now;
+    const expiresAt = entry.expiresAt ?? createdAt + ttlMs;
+    return { ...entry, createdAt, expiresAt };
+}
+export function registerDiscordComponentEntries(params) {
+    const now = Date.now();
+    const ttlMs = params.ttlMs ?? DEFAULT_COMPONENT_TTL_MS;
+    for (const entry of params.entries) {
+        const normalized = normalizeEntryTimestamps({ ...entry, messageId: params.messageId ?? entry.messageId }, now, ttlMs);
+        componentEntries.set(entry.id, normalized);
+    }
+    for (const modal of params.modals) {
+        const normalized = normalizeEntryTimestamps({ ...modal, messageId: params.messageId ?? modal.messageId }, now, ttlMs);
+        modalEntries.set(modal.id, normalized);
+    }
+}
+export function resolveDiscordComponentEntry(params) {
+    const entry = componentEntries.get(params.id);
+    if (!entry) {
+        return null;
+    }
+    const now = Date.now();
+    if (isExpired(entry, now)) {
+        componentEntries.delete(params.id);
+        return null;
+    }
+    if (params.consume !== false) {
+        componentEntries.delete(params.id);
+    }
+    return entry;
+}
+export function resolveDiscordModalEntry(params) {
+    const entry = modalEntries.get(params.id);
+    if (!entry) {
+        return null;
+    }
+    const now = Date.now();
+    if (isExpired(entry, now)) {
+        modalEntries.delete(params.id);
+        return null;
+    }
+    if (params.consume !== false) {
+        modalEntries.delete(params.id);
+    }
+    return entry;
+}
+export function clearDiscordComponentEntries() {
+    componentEntries.clear();
+    modalEntries.clear();
+}