@poolzin/pool-bot 2026.2.25 → 2026.2.26

package/dist/config/schema.labels.js

@@ -113,7 +113,7 @@ export const FIELD_LABELS = {
     "gateway.controlUi.basePath": "Control UI Base Path",
     "gateway.controlUi.root": "Control UI Assets Root",
     "gateway.controlUi.allowedOrigins": "Control UI Allowed Origins",
-    "gateway.controlUi.allowInsecureAuth": "Allow Insecure Control UI Auth",
+    "gateway.controlUi.allowInsecureAuth": "Insecure Control UI Auth Toggle",
     "gateway.controlUi.dangerouslyDisableDeviceAuth": "Dangerously Disable Control UI Device Auth",
     "gateway.http.endpoints.chatCompletions.enabled": "OpenAI Chat Completions Endpoint",
     "gateway.reload.mode": "Config Reload Mode",
@@ -163,6 +163,10 @@ export const FIELD_LABELS = {
     "agents.defaults.memorySearch.query.hybrid.vectorWeight": "Memory Search Vector Weight",
     "agents.defaults.memorySearch.query.hybrid.textWeight": "Memory Search Text Weight",
     "agents.defaults.memorySearch.query.hybrid.candidateMultiplier": "Memory Search Hybrid Candidate Multiplier",
+    "agents.defaults.memorySearch.query.hybrid.mmr.enabled": "Memory Search MMR Re-ranking",
+    "agents.defaults.memorySearch.query.hybrid.mmr.lambda": "Memory Search MMR Lambda",
+    "agents.defaults.memorySearch.query.hybrid.temporalDecay.enabled": "Memory Search Temporal Decay",
+    "agents.defaults.memorySearch.query.hybrid.temporalDecay.halfLifeDays": "Memory Search Temporal Decay Half-life (Days)",
     "agents.defaults.memorySearch.cache.enabled": "Memory Search Embedding Cache",
     "agents.defaults.memorySearch.cache.maxEntries": "Memory Search Embedding Cache Max Entries",
     memory: "Memory",
@@ -216,19 +220,31 @@ export const FIELD_LABELS = {
     "commands.restart": "Allow Restart",
     "commands.useAccessGroups": "Use Access Groups",
     "commands.ownerAllowFrom": "Command Owners",
+    "commands.ownerDisplay": "Owner ID Display",
+    "commands.ownerDisplaySecret": "Owner ID Hash Secret",
     "ui.seamColor": "Accent Color",
     "ui.assistant.name": "Assistant Name",
     "ui.assistant.avatar": "Assistant Avatar",
     "browser.evaluateEnabled": "Browser Evaluate Enabled",
     "browser.snapshotDefaults": "Browser Snapshot Defaults",
     "browser.snapshotDefaults.mode": "Browser Snapshot Mode",
+    "browser.ssrfPolicy": "Browser SSRF Policy",
+    "browser.ssrfPolicy.allowPrivateNetwork": "Browser Allow Private Network",
+    "browser.ssrfPolicy.allowedHostnames": "Browser Allowed Hostnames",
+    "browser.ssrfPolicy.hostnameAllowlist": "Browser Hostname Allowlist",
     "browser.remoteCdpTimeoutMs": "Remote CDP Timeout (ms)",
     "browser.remoteCdpHandshakeTimeoutMs": "Remote CDP Handshake Timeout (ms)",
     "session.dmScope": "DM Session Scope",
+    "session.threadBindings.enabled": "Thread Binding Enabled",
+    "session.threadBindings.ttlHours": "Thread Binding TTL (hours)",
     "session.agentToAgent.maxPingPongTurns": "Agent-to-Agent Ping-Pong Turns",
     "messages.suppressToolErrors": "Suppress Tool Error Warnings",
     "messages.ackReaction": "Ack Reaction Emoji",
     "messages.ackReactionScope": "Ack Reaction Scope",
+    "messages.statusReactions": "Status Reactions",
+    "messages.statusReactions.enabled": "Enable Status Reactions",
+    "messages.statusReactions.emojis": "Status Reaction Emojis",
+    "messages.statusReactions.timing": "Status Reaction Timing",
     "messages.inbound.debounceMs": "Inbound Message Debounce (ms)",
     "talk.apiKey": "Talk API Key",
     "channels.whatsapp": "WhatsApp",
@@ -241,13 +257,11 @@ export const FIELD_LABELS = {
     "channels.imessage": "iMessage",
     "channels.bluebubbles": "BlueBubbles",
     "channels.msteams": "MS Teams",
+    "channels.modelByChannel": "Channel Model Overrides",
     ...IRC_FIELD_LABELS,
     "channels.telegram.botToken": "Telegram Bot Token",
     "channels.telegram.dmPolicy": "Telegram DM Policy",
-    "channels.telegram.streamMode": "Telegram Stream Mode",
-    "channels.telegram.draftChunk.minChars": "Telegram Draft Chunk Min Chars",
-    "channels.telegram.draftChunk.maxChars": "Telegram Draft Chunk Max Chars",
-    "channels.telegram.draftChunk.breakPreference": "Telegram Draft Chunk Break Preference",
+    "channels.telegram.streaming": "Telegram Streaming Mode",
     "channels.telegram.retry.attempts": "Telegram Retry Attempts",
     "channels.telegram.retry.minDelayMs": "Telegram Retry Min Delay (ms)",
     "channels.telegram.retry.maxDelayMs": "Telegram Retry Max Delay (ms)",
@@ -263,14 +277,24 @@ export const FIELD_LABELS = {
     "channels.bluebubbles.dmPolicy": "BlueBubbles DM Policy",
     "channels.discord.dmPolicy": "Discord DM Policy",
     "channels.discord.dm.policy": "Discord DM Policy",
+    "channels.discord.streaming": "Discord Streaming Mode",
+    "channels.discord.streamMode": "Discord Stream Mode (Legacy)",
+    "channels.discord.draftChunk.minChars": "Discord Draft Chunk Min Chars",
+    "channels.discord.draftChunk.maxChars": "Discord Draft Chunk Max Chars",
+    "channels.discord.draftChunk.breakPreference": "Discord Draft Chunk Break Preference",
     "channels.discord.retry.attempts": "Discord Retry Attempts",
     "channels.discord.retry.minDelayMs": "Discord Retry Min Delay (ms)",
     "channels.discord.retry.maxDelayMs": "Discord Retry Max Delay (ms)",
     "channels.discord.retry.jitter": "Discord Retry Jitter",
     "channels.discord.maxLinesPerMessage": "Discord Max Lines Per Message",
+    "channels.discord.threadBindings.enabled": "Discord Thread Binding Enabled",
+    "channels.discord.threadBindings.ttlHours": "Discord Thread Binding TTL (hours)",
+    "channels.discord.threadBindings.spawnSubagentSessions": "Discord Thread-Bound Subagent Spawn",
     "channels.discord.ui.components.accentColor": "Discord Component Accent Color",
     "channels.discord.intents.presence": "Discord Presence Intent",
     "channels.discord.intents.guildMembers": "Discord Guild Members Intent",
+    "channels.discord.voice.enabled": "Discord Voice Enabled",
+    "channels.discord.voice.autoJoin": "Discord Voice Auto-Join",
     "channels.discord.pluralkit.enabled": "Discord PluralKit Enabled",
     "channels.discord.pluralkit.token": "Discord PluralKit Token",
     "channels.discord.activity": "Discord Presence Activity",
@@ -285,7 +309,9 @@ export const FIELD_LABELS = {
     "channels.slack.appToken": "Slack App Token",
     "channels.slack.userToken": "Slack User Token",
     "channels.slack.userTokenReadOnly": "Slack User Token Read Only",
-    "channels.slack.streamMode": "Slack Stream Mode",
+    "channels.slack.streaming": "Slack Streaming Mode",
+    "channels.slack.nativeStreaming": "Slack Native Streaming",
+    "channels.slack.streamMode": "Slack Stream Mode (Legacy)",
     "channels.slack.thread.historyScope": "Slack Thread History Scope",
     "channels.slack.thread.inheritParent": "Slack Thread Parent Inheritance",
     "channels.slack.thread.initialHistoryLimit": "Slack Thread Initial History Limit",
@@ -314,5 +340,11 @@ export const FIELD_LABELS = {
     "plugins.installs.*.sourcePath": "Plugin Install Source Path",
     "plugins.installs.*.installPath": "Plugin Install Path",
     "plugins.installs.*.version": "Plugin Install Version",
+    "plugins.installs.*.resolvedName": "Plugin Resolved Package Name",
+    "plugins.installs.*.resolvedVersion": "Plugin Resolved Package Version",
+    "plugins.installs.*.resolvedSpec": "Plugin Resolved Package Spec",
+    "plugins.installs.*.integrity": "Plugin Resolved Integrity",
+    "plugins.installs.*.shasum": "Plugin Resolved Shasum",
+    "plugins.installs.*.resolvedAt": "Plugin Resolution Time",
     "plugins.installs.*.installedAt": "Plugin Install Time",
 };

package/dist/config/sessions/delivery-info.js

@@ -5,9 +5,9 @@ import { loadSessionStore } from "./store.js";
  * Extract deliveryContext and threadId from a sessionKey.
  * Supports both :thread: (most channels) and :topic: (Telegram).
  */
-export function extractDeliveryInfo(sessionKey) {
+export function parseSessionThreadInfo(sessionKey) {
     if (!sessionKey) {
-        return { deliveryContext: undefined, threadId: undefined };
+        return { baseSessionKey: undefined, threadId: undefined };
     }
     const topicIndex = sessionKey.lastIndexOf(":topic:");
     const threadIndex = sessionKey.lastIndexOf(":thread:");
@@ -16,13 +16,20 @@ export function extractDeliveryInfo(sessionKey) {
     const baseSessionKey = markerIndex === -1 ? sessionKey : sessionKey.slice(0, markerIndex);
     const threadIdRaw = markerIndex === -1 ? undefined : sessionKey.slice(markerIndex + marker.length);
     const threadId = threadIdRaw?.trim() || undefined;
+    return { baseSessionKey, threadId };
+}
+export function extractDeliveryInfo(sessionKey) {
+    const { baseSessionKey, threadId } = parseSessionThreadInfo(sessionKey);
+    if (!sessionKey || !baseSessionKey) {
+        return { deliveryContext: undefined, threadId };
+    }
     let deliveryContext;
     try {
         const cfg = loadConfig();
         const storePath = resolveStorePath(cfg.session?.store);
         const store = loadSessionStore(storePath);
         let entry = store[sessionKey];
-        if (!entry?.deliveryContext && markerIndex !== -1 && baseSessionKey) {
+        if (!entry?.deliveryContext && baseSessionKey !== sessionKey) {
             entry = store[baseSessionKey];
         }
         if (entry?.deliveryContext) {

package/dist/config/sessions/main-session.js

@@ -1,8 +1,9 @@
 import { buildAgentMainSessionKey, DEFAULT_AGENT_ID, normalizeAgentId, normalizeMainKey, resolveAgentIdFromSessionKey, } from "../../routing/session-key.js";
 import { loadConfig } from "../config.js";
 export function resolveMainSessionKey(cfg) {
-    if (cfg?.session?.scope === "global")
+    if (cfg?.session?.scope === "global") {
         return "global";
+    }
     const agents = cfg?.agents?.list ?? [];
     const defaultAgentId = agents.find((agent) => agent?.default)?.id ?? agents[0]?.id ?? DEFAULT_AGENT_ID;
     const agentId = normalizeAgentId(defaultAgentId);
@@ -19,14 +20,16 @@ export function resolveAgentMainSessionKey(params) {
 }
 export function resolveExplicitAgentSessionKey(params) {
     const agentId = params.agentId?.trim();
-    if (!agentId)
+    if (!agentId) {
         return undefined;
+    }
     return resolveAgentMainSessionKey({ cfg: params.cfg, agentId });
 }
 export function canonicalizeMainSessionAlias(params) {
     const raw = params.sessionKey.trim();
-    if (!raw)
+    if (!raw) {
         return raw;
+    }
     const agentId = normalizeAgentId(params.agentId);
     const mainKey = normalizeMainKey(params.cfg?.session?.mainKey);
     const agentMainSessionKey = buildAgentMainSessionKey({ agentId, mainKey });
@@ -35,9 +38,11 @@ export function canonicalizeMainSessionAlias(params) {
         mainKey: "main",
     });
     const isMainAlias = raw === "main" || raw === mainKey || raw === agentMainSessionKey || raw === agentMainAliasKey;
-    if (params.cfg?.session?.scope === "global" && isMainAlias)
+    if (params.cfg?.session?.scope === "global" && isMainAlias) {
         return "global";
-    if (isMainAlias)
+    }
+    if (isMainAlias) {
         return agentMainSessionKey;
+    }
     return raw;
 }

package/dist/config/sessions/session-file.js

@@ -0,0 +1,33 @@
+import { resolveSessionFilePath } from "./paths.js";
+import { updateSessionStore } from "./store.js";
+export async function resolveAndPersistSessionFile(params) {
+    const { sessionId, sessionKey, sessionStore, storePath } = params;
+    const baseEntry = params.sessionEntry ??
+        sessionStore[sessionKey] ?? { sessionId, updatedAt: Date.now() };
+    const fallbackSessionFile = params.fallbackSessionFile?.trim();
+    const entryForResolve = !baseEntry.sessionFile && fallbackSessionFile
+        ? { ...baseEntry, sessionFile: fallbackSessionFile }
+        : baseEntry;
+    const sessionFile = resolveSessionFilePath(sessionId, entryForResolve, {
+        agentId: params.agentId,
+        sessionsDir: params.sessionsDir,
+    });
+    const persistedEntry = {
+        ...baseEntry,
+        sessionId,
+        updatedAt: Date.now(),
+        sessionFile,
+    };
+    if (baseEntry.sessionId !== sessionId || baseEntry.sessionFile !== sessionFile) {
+        sessionStore[sessionKey] = persistedEntry;
+        await updateSessionStore(storePath, (store) => {
+            store[sessionKey] = {
+                ...store[sessionKey],
+                ...persistedEntry,
+            };
+        }, params.activeSessionKey ? { activeSessionKey: params.activeSessionKey } : undefined);
+        return { sessionFile, sessionEntry: persistedEntry };
+    }
+    sessionStore[sessionKey] = persistedEntry;
+    return { sessionFile, sessionEntry: persistedEntry };
+}

package/dist/config/sessions/session-key.js

@@ -3,11 +3,13 @@ import { normalizeE164 } from "../../utils.js";
 import { resolveGroupSessionKey } from "./group.js";
 // Decide which session bucket to use (per-sender vs global).
 export function deriveSessionKey(scope, ctx) {
-    if (scope === "global")
+    if (scope === "global") {
         return "global";
+    }
     const resolvedGroup = resolveGroupSessionKey(ctx);
-    if (resolvedGroup)
+    if (resolvedGroup) {
         return resolvedGroup.key;
+    }
     const from = ctx.From ? normalizeE164(ctx.From) : "";
     return from || "unknown";
 }
@@ -17,18 +19,21 @@ export function deriveSessionKey(scope, ctx) {
  */
 export function resolveSessionKey(scope, ctx, mainKey) {
     const explicit = ctx.SessionKey?.trim();
-    if (explicit)
+    if (explicit) {
         return explicit.toLowerCase();
+    }
     const raw = deriveSessionKey(scope, ctx);
-    if (scope === "global")
+    if (scope === "global") {
         return raw;
+    }
     const canonicalMainKey = normalizeMainKey(mainKey);
     const canonical = buildAgentMainSessionKey({
         agentId: DEFAULT_AGENT_ID,
         mainKey: canonicalMainKey,
     });
     const isGroup = raw.includes(":group:") || raw.includes(":channel:");
-    if (!isGroup)
+    if (!isGroup) {
         return canonical;
+    }
     return `agent:${DEFAULT_AGENT_ID}:${raw}`;
 }

package/dist/config/sessions/store.js

@@ -472,7 +472,7 @@ async function saveSessionStoreUnlocked(storePath, store, opts) {
                     // Final attempt failed — skip this save.  The write lock ensures
                     // the next save will retry with fresh data.  Log for diagnostics.
                     if (i === 4) {
-                        console.warn(`[session-store] rename failed after 5 attempts: ${storePath}`);
+                        log.warn(`rename failed after 5 attempts: ${storePath}`);
                     }
                 }
             }

package/dist/config/sessions.js

@@ -7,4 +7,5 @@ export * from "./sessions/session-key.js";
 export * from "./sessions/store.js";
 export * from "./sessions/types.js";
 export * from "./sessions/transcript.js";
+export * from "./sessions/session-file.js";
 export * from "./sessions/delivery-info.js";

package/dist/config/zod-schema.agent-runtime.js

@@ -168,7 +168,9 @@ export const SandboxBrowserSchema = z
     enabled: z.boolean().optional(),
     image: z.string().optional(),
     containerPrefix: z.string().optional(),
+    network: z.string().optional(),
     cdpPort: z.number().int().positive().optional(),
+    cdpSourceRange: z.string().optional(),
     vncPort: z.number().int().positive().optional(),
     noVncPort: z.number().int().positive().optional(),
     headless: z.boolean().optional(),
@@ -177,6 +179,15 @@ export const SandboxBrowserSchema = z
     autoStart: z.boolean().optional(),
     autoStartTimeoutMs: z.number().int().positive().optional(),
     binds: z.array(z.string()).optional(),
+})
+    .superRefine((data, ctx) => {
+    if (data.network?.trim().toLowerCase() === "host") {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["network"],
+            message: 'Sandbox security: browser network mode "host" is blocked. Use "bridge" or a custom bridge network instead.',
+        });
+    }
 })
     .strict()
     .optional();

package/dist/config/zod-schema.js

@@ -1,12 +1,13 @@
 import { z } from "zod";
 import { ToolsSchema } from "./zod-schema.agent-runtime.js";
-import { ApprovalsSchema } from "./zod-schema.approvals.js";
 import { AgentsSchema, AudioSchema, BindingsSchema, BroadcastSchema } from "./zod-schema.agents.js";
+import { ApprovalsSchema } from "./zod-schema.approvals.js";
 import { HexColorSchema, ModelsConfigSchema } from "./zod-schema.core.js";
 import { HookMappingSchema, HooksGmailSchema, InternalHooksSchema } from "./zod-schema.hooks.js";
+import { InstallRecordShape } from "./zod-schema.installs.js";
 import { ChannelsSchema } from "./zod-schema.providers.js";
-import { CommandsSchema, MessagesSchema, SessionSchema } from "./zod-schema.session.js";
 import { sensitive } from "./zod-schema.sensitive.js";
+import { CommandsSchema, MessagesSchema, SessionSchema, SessionSendPolicySchema, } from "./zod-schema.session.js";
 const BrowserSnapshotDefaultsSchema = z
     .object({
     mode: z.literal("efficient").optional(),
@@ -25,8 +26,78 @@ const NodeHostSchema = z
 })
     .strict()
     .optional();
+const MemoryQmdPathSchema = z
+    .object({
+    path: z.string(),
+    name: z.string().optional(),
+    pattern: z.string().optional(),
+})
+    .strict();
+const MemoryQmdSessionSchema = z
+    .object({
+    enabled: z.boolean().optional(),
+    exportDir: z.string().optional(),
+    retentionDays: z.number().int().nonnegative().optional(),
+})
+    .strict();
+const MemoryQmdUpdateSchema = z
+    .object({
+    interval: z.string().optional(),
+    debounceMs: z.number().int().nonnegative().optional(),
+    onBoot: z.boolean().optional(),
+    waitForBootSync: z.boolean().optional(),
+    embedInterval: z.string().optional(),
+    commandTimeoutMs: z.number().int().nonnegative().optional(),
+    updateTimeoutMs: z.number().int().nonnegative().optional(),
+    embedTimeoutMs: z.number().int().nonnegative().optional(),
+})
+    .strict();
+const MemoryQmdLimitsSchema = z
+    .object({
+    maxResults: z.number().int().positive().optional(),
+    maxSnippetChars: z.number().int().positive().optional(),
+    maxInjectedChars: z.number().int().positive().optional(),
+    timeoutMs: z.number().int().nonnegative().optional(),
+})
+    .strict();
+const MemoryQmdMcporterSchema = z
+    .object({
+    enabled: z.boolean().optional(),
+    serverName: z.string().optional(),
+    startDaemon: z.boolean().optional(),
+})
+    .strict();
+const MemoryQmdSchema = z
+    .object({
+    command: z.string().optional(),
+    mcporter: MemoryQmdMcporterSchema.optional(),
+    searchMode: z.union([z.literal("query"), z.literal("search"), z.literal("vsearch")]).optional(),
+    includeDefaultMemory: z.boolean().optional(),
+    paths: z.array(MemoryQmdPathSchema).optional(),
+    sessions: MemoryQmdSessionSchema.optional(),
+    update: MemoryQmdUpdateSchema.optional(),
+    limits: MemoryQmdLimitsSchema.optional(),
+    scope: SessionSendPolicySchema.optional(),
+})
+    .strict();
+const MemorySchema = z
+    .object({
+    backend: z.union([z.literal("builtin"), z.literal("qmd")]).optional(),
+    citations: z.union([z.literal("auto"), z.literal("on"), z.literal("off")]).optional(),
+    qmd: MemoryQmdSchema.optional(),
+})
+    .strict()
+    .optional();
+const HttpUrlSchema = z
+    .string()
+    .url()
+    .refine((value) => {
+    const protocol = new URL(value).protocol;
+    return protocol === "http:" || protocol === "https:";
+}, "Expected http:// or https:// URL");
 export const PoolBotSchema = z
     .object({
+    $schema: z.string().optional(),
     meta: z
         .object({
         lastTouchedVersion: z.string().optional(),
@@ -143,6 +214,14 @@ export const PoolBotSchema = z
         attachOnly: z.boolean().optional(),
         defaultProfile: z.string().optional(),
         snapshotDefaults: BrowserSnapshotDefaultsSchema,
+        ssrfPolicy: z
+            .object({
+            allowPrivateNetwork: z.boolean().optional(),
+            allowedHostnames: z.array(z.string()).optional(),
+            hostnameAllowlist: z.array(z.string()).optional(),
+        })
+            .strict()
+            .optional(),
         profiles: z
             .record(z
             .string()
@@ -220,6 +299,9 @@ export const PoolBotSchema = z
         enabled: z.boolean().optional(),
         store: z.string().optional(),
         maxConcurrentRuns: z.number().int().positive().optional(),
+        webhook: HttpUrlSchema.optional(),
+        webhookToken: z.string().optional().register(sensitive),
+        sessionRetention: z.union([z.string(), z.literal(false)]).optional(),
     })
         .strict()
         .optional(),
@@ -228,6 +310,10 @@ export const PoolBotSchema = z
         enabled: z.boolean().optional(),
         path: z.string().optional(),
         token: z.string().optional().register(sensitive),
+        defaultSessionKey: z.string().optional(),
+        allowRequestSessionKey: z.boolean().optional(),
+        allowedSessionKeyPrefixes: z.array(z.string()).optional(),
+        allowedAgentIds: z.array(z.string()).optional(),
         maxBodyBytes: z.number().int().positive().optional(),
         presets: z.array(z.string()).optional(),
         transformsDir: z.string().optional(),
@@ -305,10 +391,13 @@ export const PoolBotSchema = z
             z.literal("tailnet"),
         ])
             .optional(),
+        customBindHost: z.string().optional(),
         controlUi: z
             .object({
             enabled: z.boolean().optional(),
             basePath: z.string().optional(),
+            root: z.string().optional(),
+            allowedOrigins: z.array(z.string()).optional(),
             allowInsecureAuth: z.boolean().optional(),
             dangerouslyDisableDeviceAuth: z.boolean().optional(),
         })
@@ -316,14 +405,47 @@ export const PoolBotSchema = z
             .optional(),
         auth: z
             .object({
-            mode: z.union([z.literal("token"), z.literal("password")]).optional(),
+            mode: z
+                .union([
+                z.literal("none"),
+                z.literal("token"),
+                z.literal("password"),
+                z.literal("trusted-proxy"),
+            ])
+                .optional(),
             token: z.string().optional().register(sensitive),
             password: z.string().optional().register(sensitive),
             allowTailscale: z.boolean().optional(),
+            rateLimit: z
+                .object({
+                maxAttempts: z.number().optional(),
+                windowMs: z.number().optional(),
+                lockoutMs: z.number().optional(),
+                exemptLoopback: z.boolean().optional(),
+            })
+                .strict()
+                .optional(),
+            trustedProxy: z
+                .object({
+                userHeader: z.string().min(1, "userHeader is required for trusted-proxy mode"),
+                requiredHeaders: z.array(z.string()).optional(),
+                allowUsers: z.array(z.string()).optional(),
+            })
+                .strict()
+                .optional(),
         })
             .strict()
             .optional(),
         trustedProxies: z.array(z.string()).optional(),
+        allowRealIpFallback: z.boolean().optional(),
+        tools: z
+            .object({
+            deny: z.array(z.string()).optional(),
+            allow: z.array(z.string()).optional(),
+        })
+            .strict()
+            .optional(),
+        channelHealthCheckMinutes: z.number().int().min(0).optional(),
         tailscale: z
             .object({
             mode: z.union([z.literal("off"), z.literal("serve"), z.literal("funnel")]).optional(),
@@ -380,9 +502,11 @@ export const PoolBotSchema = z
                     .object({
                     enabled: z.boolean().optional(),
                     maxBodyBytes: z.number().int().positive().optional(),
+                    maxUrlParts: z.number().int().nonnegative().optional(),
                     files: z
                         .object({
                         allowUrl: z.boolean().optional(),
+                        urlAllowlist: z.array(z.string()).optional(),
                         allowedMimes: z.array(z.string()).optional(),
                         maxBytes: z.number().int().positive().optional(),
                         maxChars: z.number().int().positive().optional(),
@@ -402,6 +526,7 @@ export const PoolBotSchema = z
                     images: z
                         .object({
                         allowUrl: z.boolean().optional(),
+                        urlAllowlist: z.array(z.string()).optional(),
                         allowedMimes: z.array(z.string()).optional(),
                         maxBytes: z.number().int().positive().optional(),
                         maxRedirects: z.number().int().nonnegative().optional(),
@@ -437,6 +562,7 @@ export const PoolBotSchema = z
     })
         .strict()
         .optional(),
+    memory: MemorySchema,
     skills: z
         .object({
         allowBundled: z.array(z.string()).optional(),
@@ -457,6 +583,16 @@ export const PoolBotSchema = z
         })
             .strict()
             .optional(),
+        limits: z
+            .object({
+            maxCandidatesPerRoot: z.number().int().min(1).optional(),
+            maxSkillsLoadedPerSource: z.number().int().min(1).optional(),
+            maxSkillsInPrompt: z.number().int().min(0).optional(),
+            maxSkillsPromptChars: z.number().int().min(0).optional(),
+            maxSkillFileBytes: z.number().int().min(0).optional(),
+        })
+            .strict()
+            .optional(),
         entries: z
             .record(z.string(), z
             .object({
@@ -498,12 +634,7 @@ export const PoolBotSchema = z
         installs: z
             .record(z.string(), z
             .object({
-            source: z.union([z.literal("npm"), z.literal("archive"), z.literal("path")]),
-            spec: z.string().optional(),
-            sourcePath: z.string().optional(),
-            installPath: z.string().optional(),
-            version: z.string().optional(),
-            installedAt: z.string().optional(),
+            ...InstallRecordShape,
         })
             .strict())
             .optional(),
@@ -514,17 +645,21 @@ export const PoolBotSchema = z
     .strict()
     .superRefine((cfg, ctx) => {
     const agents = cfg.agents?.list ?? [];
-    if (agents.length === 0)
+    if (agents.length === 0) {
         return;
+    }
     const agentIds = new Set(agents.map((agent) => agent.id));
     const broadcast = cfg.broadcast;
-    if (!broadcast)
+    if (!broadcast) {
         return;
+    }
     for (const [peerId, ids] of Object.entries(broadcast)) {
-        if (peerId === "strategy")
+        if (peerId === "strategy") {
             continue;
-        if (!Array.isArray(ids))
+        }
+        if (!Array.isArray(ids)) {
             continue;
+        }
         for (let idx = 0; idx < ids.length; idx += 1) {
             const agentId = ids[idx];
             if (!agentIds.has(agentId)) {