@poolzin/pool-bot 2026.3.4 → 2026.3.7

package/dist/shared/net/ip.js

@@ -0,0 +1,303 @@
+import ipaddr from "ipaddr.js";
+const BLOCKED_IPV4_SPECIAL_USE_RANGES = new Set([
+    "unspecified",
+    "broadcast",
+    "multicast",
+    "linkLocal",
+    "loopback",
+    "carrierGradeNat",
+    "private",
+    "reserved",
+]);
+const PRIVATE_OR_LOOPBACK_IPV4_RANGES = new Set([
+    "loopback",
+    "private",
+    "linkLocal",
+    "carrierGradeNat",
+]);
+const BLOCKED_IPV6_SPECIAL_USE_RANGES = new Set([
+    "unspecified",
+    "loopback",
+    "linkLocal",
+    "uniqueLocal",
+    "multicast",
+]);
+const RFC2544_BENCHMARK_PREFIX = [ipaddr.IPv4.parse("198.18.0.0"), 15];
+const EMBEDDED_IPV4_SENTINEL_RULES = [
+    {
+        // IPv4-compatible form ::w.x.y.z (deprecated, but still seen in parser edge-cases).
+        matches: (parts) => parts[0] === 0 &&
+            parts[1] === 0 &&
+            parts[2] === 0 &&
+            parts[3] === 0 &&
+            parts[4] === 0 &&
+            parts[5] === 0,
+        toHextets: (parts) => [parts[6], parts[7]],
+    },
+    {
+        // NAT64 local-use prefix: 64:ff9b:1::/48.
+        matches: (parts) => parts[0] === 0x0064 &&
+            parts[1] === 0xff9b &&
+            parts[2] === 0x0001 &&
+            parts[3] === 0 &&
+            parts[4] === 0 &&
+            parts[5] === 0,
+        toHextets: (parts) => [parts[6], parts[7]],
+    },
+    {
+        // 6to4 prefix: 2002::/16 (IPv4 lives in hextets 1..2).
+        matches: (parts) => parts[0] === 0x2002,
+        toHextets: (parts) => [parts[1], parts[2]],
+    },
+    {
+        // Teredo prefix: 2001:0000::/32 (client IPv4 XOR 0xffff in hextets 6..7).
+        matches: (parts) => parts[0] === 0x2001 && parts[1] === 0x0000,
+        toHextets: (parts) => [parts[6] ^ 0xffff, parts[7] ^ 0xffff],
+    },
+    {
+        // ISATAP IID marker: ....:0000:5efe:w.x.y.z with u/g bits allowed in hextet 4.
+        matches: (parts) => (parts[4] & 0xfcff) === 0 && parts[5] === 0x5efe,
+        toHextets: (parts) => [parts[6], parts[7]],
+    },
+];
+function stripIpv6Brackets(value) {
+    if (value.startsWith("[") && value.endsWith("]")) {
+        return value.slice(1, -1);
+    }
+    return value;
+}
+function isNumericIpv4LiteralPart(value) {
+    return /^[0-9]+$/.test(value) || /^0x[0-9a-f]+$/i.test(value);
+}
+function parseIpv6WithEmbeddedIpv4(raw) {
+    if (!raw.includes(":") || !raw.includes(".")) {
+        return undefined;
+    }
+    const match = /^(.*:)([^:%]+(?:\.[^:%]+){3})(%[0-9A-Za-z]+)?$/i.exec(raw);
+    if (!match) {
+        return undefined;
+    }
+    const [, prefix, embeddedIpv4, zoneSuffix = ""] = match;
+    if (!ipaddr.IPv4.isValidFourPartDecimal(embeddedIpv4)) {
+        return undefined;
+    }
+    const octets = embeddedIpv4.split(".").map((part) => Number.parseInt(part, 10));
+    const high = ((octets[0] << 8) | octets[1]).toString(16);
+    const low = ((octets[2] << 8) | octets[3]).toString(16);
+    const normalizedIpv6 = `${prefix}${high}:${low}${zoneSuffix}`;
+    if (!ipaddr.IPv6.isValid(normalizedIpv6)) {
+        return undefined;
+    }
+    return ipaddr.IPv6.parse(normalizedIpv6);
+}
+export function isIpv4Address(address) {
+    return address.kind() === "ipv4";
+}
+export function isIpv6Address(address) {
+    return address.kind() === "ipv6";
+}
+function normalizeIpv4MappedAddress(address) {
+    if (!isIpv6Address(address)) {
+        return address;
+    }
+    if (!address.isIPv4MappedAddress()) {
+        return address;
+    }
+    return address.toIPv4Address();
+}
+export function parseCanonicalIpAddress(raw) {
+    const trimmed = raw?.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const normalized = stripIpv6Brackets(trimmed);
+    if (!normalized) {
+        return undefined;
+    }
+    if (ipaddr.IPv4.isValid(normalized)) {
+        if (!ipaddr.IPv4.isValidFourPartDecimal(normalized)) {
+            return undefined;
+        }
+        return ipaddr.IPv4.parse(normalized);
+    }
+    if (ipaddr.IPv6.isValid(normalized)) {
+        return ipaddr.IPv6.parse(normalized);
+    }
+    return parseIpv6WithEmbeddedIpv4(normalized);
+}
+export function parseLooseIpAddress(raw) {
+    const trimmed = raw?.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const normalized = stripIpv6Brackets(trimmed);
+    if (!normalized) {
+        return undefined;
+    }
+    if (ipaddr.isValid(normalized)) {
+        return ipaddr.parse(normalized);
+    }
+    return parseIpv6WithEmbeddedIpv4(normalized);
+}
+export function normalizeIpAddress(raw) {
+    const parsed = parseCanonicalIpAddress(raw);
+    if (!parsed) {
+        return undefined;
+    }
+    const normalized = normalizeIpv4MappedAddress(parsed);
+    return normalized.toString().toLowerCase();
+}
+export function isCanonicalDottedDecimalIPv4(raw) {
+    const trimmed = raw?.trim();
+    if (!trimmed) {
+        return false;
+    }
+    const normalized = stripIpv6Brackets(trimmed);
+    if (!normalized) {
+        return false;
+    }
+    return ipaddr.IPv4.isValidFourPartDecimal(normalized);
+}
+export function isLegacyIpv4Literal(raw) {
+    const trimmed = raw?.trim();
+    if (!trimmed) {
+        return false;
+    }
+    const normalized = stripIpv6Brackets(trimmed);
+    if (!normalized || normalized.includes(":")) {
+        return false;
+    }
+    if (isCanonicalDottedDecimalIPv4(normalized)) {
+        return false;
+    }
+    const parts = normalized.split(".");
+    if (parts.length === 0 || parts.length > 4) {
+        return false;
+    }
+    if (parts.some((part) => part.length === 0)) {
+        return false;
+    }
+    if (!parts.every((part) => isNumericIpv4LiteralPart(part))) {
+        return false;
+    }
+    return true;
+}
+export function isLoopbackIpAddress(raw) {
+    const parsed = parseCanonicalIpAddress(raw);
+    if (!parsed) {
+        return false;
+    }
+    const normalized = normalizeIpv4MappedAddress(parsed);
+    return normalized.range() === "loopback";
+}
+export function isPrivateOrLoopbackIpAddress(raw) {
+    const parsed = parseCanonicalIpAddress(raw);
+    if (!parsed) {
+        return false;
+    }
+    const normalized = normalizeIpv4MappedAddress(parsed);
+    if (isIpv4Address(normalized)) {
+        return PRIVATE_OR_LOOPBACK_IPV4_RANGES.has(normalized.range());
+    }
+    return isBlockedSpecialUseIpv6Address(normalized);
+}
+export function isBlockedSpecialUseIpv6Address(address) {
+    if (BLOCKED_IPV6_SPECIAL_USE_RANGES.has(address.range())) {
+        return true;
+    }
+    // ipaddr.js does not classify deprecated site-local fec0::/10 as private.
+    return (address.parts[0] & 0xffc0) === 0xfec0;
+}
+export function isRfc1918Ipv4Address(raw) {
+    const parsed = parseCanonicalIpAddress(raw);
+    if (!parsed || !isIpv4Address(parsed)) {
+        return false;
+    }
+    return parsed.range() === "private";
+}
+export function isCarrierGradeNatIpv4Address(raw) {
+    const parsed = parseCanonicalIpAddress(raw);
+    if (!parsed || !isIpv4Address(parsed)) {
+        return false;
+    }
+    return parsed.range() === "carrierGradeNat";
+}
+export function isBlockedSpecialUseIpv4Address(address, options = {}) {
+    const inRfc2544BenchmarkRange = address.match(RFC2544_BENCHMARK_PREFIX);
+    if (inRfc2544BenchmarkRange && options.allowRfc2544BenchmarkRange === true) {
+        return false;
+    }
+    return BLOCKED_IPV4_SPECIAL_USE_RANGES.has(address.range()) || inRfc2544BenchmarkRange;
+}
+function decodeIpv4FromHextets(high, low) {
+    const octets = [
+        (high >>> 8) & 0xff,
+        high & 0xff,
+        (low >>> 8) & 0xff,
+        low & 0xff,
+    ];
+    return ipaddr.IPv4.parse(octets.join("."));
+}
+export function extractEmbeddedIpv4FromIpv6(address) {
+    if (address.isIPv4MappedAddress()) {
+        return address.toIPv4Address();
+    }
+    if (address.range() === "rfc6145") {
+        return decodeIpv4FromHextets(address.parts[6], address.parts[7]);
+    }
+    if (address.range() === "rfc6052") {
+        return decodeIpv4FromHextets(address.parts[6], address.parts[7]);
+    }
+    for (const rule of EMBEDDED_IPV4_SENTINEL_RULES) {
+        if (!rule.matches(address.parts)) {
+            continue;
+        }
+        const [high, low] = rule.toHextets(address.parts);
+        return decodeIpv4FromHextets(high, low);
+    }
+    return undefined;
+}
+export function isIpInCidr(ip, cidr) {
+    const normalizedIp = parseCanonicalIpAddress(ip);
+    if (!normalizedIp) {
+        return false;
+    }
+    const candidate = cidr.trim();
+    if (!candidate) {
+        return false;
+    }
+    const comparableIp = normalizeIpv4MappedAddress(normalizedIp);
+    if (!candidate.includes("/")) {
+        const exact = parseCanonicalIpAddress(candidate);
+        if (!exact) {
+            return false;
+        }
+        const comparableExact = normalizeIpv4MappedAddress(exact);
+        return (comparableIp.kind() === comparableExact.kind() &&
+            comparableIp.toString() === comparableExact.toString());
+    }
+    let parsedCidr;
+    try {
+        parsedCidr = ipaddr.parseCIDR(candidate);
+    }
+    catch {
+        return false;
+    }
+    const [baseAddress, prefixLength] = parsedCidr;
+    const comparableBase = normalizeIpv4MappedAddress(baseAddress);
+    if (comparableIp.kind() !== comparableBase.kind()) {
+        return false;
+    }
+    try {
+        if (isIpv4Address(comparableIp) && isIpv4Address(comparableBase)) {
+            return comparableIp.match([comparableBase, prefixLength]);
+        }
+        if (isIpv6Address(comparableIp) && isIpv6Address(comparableBase)) {
+            return comparableIp.match([comparableBase, prefixLength]);
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/shared/net/ipv4.js

@@ -1,17 +1,14 @@
-export function validateIPv4AddressInput(value) {
+import { isCanonicalDottedDecimalIPv4 } from "./ip.js";
+export function validateDottedDecimalIPv4Input(value) {
     if (!value) {
         return "IP address is required for custom bind mode";
     }
-    const trimmed = value.trim();
-    const parts = trimmed.split(".");
-    if (parts.length !== 4) {
-        return "Invalid IPv4 address (e.g., 192.168.1.100)";
-    }
-    if (parts.every((part) => {
-        const n = parseInt(part, 10);
-        return !Number.isNaN(n) && n >= 0 && n <= 255 && part === String(n);
-    })) {
+    if (isCanonicalDottedDecimalIPv4(value)) {
         return undefined;
     }
-    return "Invalid IPv4 address (each octet must be 0-255)";
+    return "Invalid IPv4 address (e.g., 192.168.1.100)";
+}
+// Backward-compatible alias for callers using the old helper name.
+export function validateIPv4AddressInput(value) {
+    return validateDottedDecimalIPv4Input(value);
 }

package/dist/shared/pid-alive.js

@@ -1,12 +1,69 @@
+import fsSync from "node:fs";
+function isValidPid(pid) {
+    return Number.isInteger(pid) && pid > 0;
+}
+/**
+ * Check if a process is a zombie on Linux by reading /proc/<pid>/status.
+ * Returns false on non-Linux platforms or if the proc file can't be read.
+ */
+function isZombieProcess(pid) {
+    if (process.platform !== "linux") {
+        return false;
+    }
+    try {
+        const status = fsSync.readFileSync(`/proc/${pid}/status`, "utf8");
+        const stateMatch = status.match(/^State:\s+(\S)/m);
+        return stateMatch?.[1] === "Z";
+    }
+    catch {
+        return false;
+    }
+}
 export function isPidAlive(pid) {
-    if (!Number.isFinite(pid) || pid <= 0) {
+    if (!isValidPid(pid)) {
         return false;
     }
     try {
         process.kill(pid, 0);
-        return true;
     }
     catch {
         return false;
     }
+    if (isZombieProcess(pid)) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Read the process start time (field 22 "starttime") from /proc/<pid>/stat.
+ * Returns the value in clock ticks since system boot, or null on non-Linux
+ * platforms or if the proc file can't be read.
+ *
+ * This is used to detect PID recycling: if two readings for the same PID
+ * return different starttimes, the PID has been reused by a different process.
+ */
+export function getProcessStartTime(pid) {
+    if (process.platform !== "linux") {
+        return null;
+    }
+    if (!isValidPid(pid)) {
+        return null;
+    }
+    try {
+        const stat = fsSync.readFileSync(`/proc/${pid}/stat`, "utf8");
+        const commEndIndex = stat.lastIndexOf(")");
+        if (commEndIndex < 0) {
+            return null;
+        }
+        // The comm field (field 2) is wrapped in parens and can contain spaces,
+        // so split after the last ")" to get fields 3..N reliably.
+        const afterComm = stat.slice(commEndIndex + 1).trimStart();
+        const fields = afterComm.split(/\s+/);
+        // field 22 (starttime) = index 19 after the comm-split (field 3 is index 0).
+        const starttime = Number(fields[19]);
+        return Number.isInteger(starttime) && starttime >= 0 ? starttime : null;
+    }
+    catch {
+        return null;
+    }
 }

package/dist/slack/monitor/context.js

@@ -228,6 +228,7 @@ export function createSlackMonitorContext(params) {
         slashCommand: params.slashCommand,
         textLimit: params.textLimit,
         ackReactionScope: params.ackReactionScope,
+        typingReaction: params.typingReaction,
         mediaMaxBytes: params.mediaMaxBytes,
         removeAckAfterReply: params.removeAckAfterReply,
         logger,

package/dist/slack/monitor/message-handler/dispatch.js

@@ -8,7 +8,7 @@ import { createReplyPrefixOptions } from "../../../channels/reply-prefix.js";
 import { createTypingCallbacks } from "../../../channels/typing.js";
 import { resolveStorePath, updateLastRoute } from "../../../config/sessions.js";
 import { danger, logVerbose, shouldLogVerbose } from "../../../globals.js";
-import { removeSlackReaction } from "../../actions.js";
+import { reactSlackMessage, removeSlackReaction } from "../../actions.js";
 import { createSlackDraftStream } from "../../draft-stream.js";
 import { applyAppendOnlyStreamUpdate, buildStatusFinalPreviewText, resolveSlackStreamingConfig, } from "../../stream-mode.js";
 import { appendSlackStream, startSlackStream, stopSlackStream } from "../../streaming.js";
@@ -78,6 +78,7 @@ export async function dispatchPreparedSlackMessage(prepared) {
         hasRepliedRef,
     });
     const typingTarget = statusThreadTs ? `${message.channel}/${statusThreadTs}` : message.channel;
+    const typingReaction = ctx.typingReaction;
     const typingCallbacks = createTypingCallbacks({
         start: async () => {
             didSetStatus = true;
@@ -86,6 +87,12 @@ export async function dispatchPreparedSlackMessage(prepared) {
                 threadTs: statusThreadTs,
                 status: "is typing...",
             });
+            if (typingReaction && message.ts) {
+                await reactSlackMessage(message.channel, message.ts, typingReaction, {
+                    token: ctx.botToken,
+                    client: ctx.app.client,
+                }).catch(() => { });
+            }
         },
         stop: async () => {
             if (!didSetStatus) {
@@ -97,6 +104,12 @@ export async function dispatchPreparedSlackMessage(prepared) {
                 threadTs: statusThreadTs,
                 status: "",
             });
+            if (typingReaction && message.ts) {
+                await removeSlackReaction(message.channel, message.ts, typingReaction, {
+                    token: ctx.botToken,
+                    client: ctx.app.client,
+                }).catch(() => { });
+            }
         },
         onStartError: (err) => {
             logTypingFailure({

package/dist/slack/monitor/provider.js

@@ -90,6 +90,7 @@ export async function monitorSlackProvider(opts = {}) {
     const ackReactionScope = cfg.messages?.ackReactionScope ?? "group-mentions";
     const mediaMaxBytes = (opts.mediaMaxMb ?? slackCfg.mediaMaxMb ?? 20) * 1024 * 1024;
     const removeAckAfterReply = cfg.messages?.removeAckAfterReply ?? false;
+    const typingReaction = slackCfg.typingReaction ?? "";
     const receiver = slackMode === "http"
         ? new HTTPReceiver({
             signingSecret: signingSecret ?? "",
@@ -160,6 +161,7 @@ export async function monitorSlackProvider(opts = {}) {
         slashCommand,
         textLimit,
         ackReactionScope,
+        typingReaction,
         mediaMaxBytes,
         removeAckAfterReply,
     });

package/dist/test-helpers/ssrf.js

@@ -0,0 +1,13 @@
+import { vi } from "vitest";
+import * as ssrf from "../infra/net/ssrf.js";
+export function mockPinnedHostnameResolution(addresses = ["93.184.216.34"]) {
+    return vi.spyOn(ssrf, "resolvePinnedHostname").mockImplementation(async (hostname) => {
+        const normalized = hostname.trim().toLowerCase().replace(/\.$/, "");
+        const pinnedAddresses = [...addresses];
+        return {
+            hostname: normalized,
+            addresses: pinnedAddresses,
+            lookup: ssrf.createPinnedLookup({ hostname: normalized, addresses: pinnedAddresses }),
+        };
+    });
+}

package/dist/tui/tui.js

@@ -1,4 +1,4 @@
-import { CombinedAutocompleteProvider, Container, Key, Loader, matchesKey, ProcessTerminal, Text, TUI, } from "@mariozechner/pi-tui";
+import { CombinedAutocompleteProvider, Container, Key, Loader, matchesKey, ProcessTerminal, Text, TUI, truncateToWidth, } from "@mariozechner/pi-tui";
 import { resolveDefaultAgentId } from "../agents/agent-scope.js";
 import { loadConfig } from "../config/config.js";
 import { buildAgentMainSessionKey, normalizeAgentId, normalizeMainKey, parseAgentSessionKey, } from "../routing/session-key.js";
@@ -398,7 +398,9 @@ export async function runTui(opts) {
     const updateHeader = () => {
         const sessionLabel = formatSessionKey(currentSessionKey);
         const agentLabel = formatAgentLabel(currentAgentId);
-        header.setText(theme.header(`poolbot tui - ${client.connection.url} - agent ${agentLabel} - session ${sessionLabel}`));
+        const headerText = `poolbot tui - ${client.connection.url} - agent ${agentLabel} - session ${sessionLabel}`;
+        const maxHeaderWidth = Math.max(1, (process.stdout.columns ?? 120) - 2);
+        header.setText(theme.header(truncateToWidth(headerText, maxHeaderWidth, "…")));
     };
     const busyStates = new Set(["sending", "waiting", "streaming", "running"]);
     let statusText = null;
@@ -520,7 +522,8 @@ export async function runTui(opts) {
             statusLoader = null;
             ensureStatusText();
             const text = activityStatus ? `${connectionStatus} | ${activityStatus}` : connectionStatus;
-            statusText?.setText(theme.dim(text));
+            const maxStatusWidth = Math.max(1, (process.stdout.columns ?? 120) - 2);
+            statusText?.setText(theme.dim(truncateToWidth(text, maxStatusWidth, "…")));
         }
         lastActivityStatus = activityStatus;
     };
@@ -566,7 +569,9 @@ export async function runTui(opts) {
             reasoningLabel,
             tokens,
         ].filter(Boolean);
-        footer.setText(theme.dim(footerParts.join(" | ")));
+        const footerText = footerParts.join(" | ");
+        const maxFooterWidth = Math.max(1, (process.stdout.columns ?? 120) - 2);
+        footer.setText(theme.dim(truncateToWidth(footerText, maxFooterWidth, "…")));
     };
     const { openOverlay, closeOverlay } = createOverlayHandlers(tui, editor);
     const initialSessionAgentId = (() => {

package/dist/utils/fetch-timeout.js

@@ -1,3 +1,14 @@
+/**
+ * Relay abort without forwarding the Event argument as the abort reason.
+ * Using .bind() avoids closure scope capture (memory leak prevention).
+ */
+function relayAbort() {
+    this.abort();
+}
+/** Returns a bound abort relay for use as an event listener. */
+export function bindAbortRelay(controller) {
+    return relayAbort.bind(controller);
+}
 /**
  * Fetch wrapper that adds timeout support via AbortController.
  *
@@ -10,7 +21,7 @@
  */
 export async function fetchWithTimeout(url, init, timeoutMs, fetchFn = fetch) {
     const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), Math.max(1, timeoutMs));
+    const timer = setTimeout(controller.abort.bind(controller), Math.max(1, timeoutMs));
     try {
         return await fetchFn(url, { ...init, signal: controller.signal });
     }

package/docs/adr/003-feature-gap-analysis.md

@@ -0,0 +1,112 @@
+# ADR 003: Feature Gap Analysis — Pool Bot vs OpenClaw
+
+**Status:** Accepted  
+**Date:** 2026-03-04  
+**Author:** PLCode analysis agent
+
+## Context
+
+Pool Bot (v2026.3.4) was forked from OpenClaw. OpenClaw has continued shipping features through versions 2026.2.12 to 2026.3.3 that Pool Bot has not yet adopted. This document identifies the highest-value gaps and prioritizes implementation.
+
+## Analysis Method
+
+- Full diff of both CHANGELOGs (2000+ OpenClaw lines vs 297 Pool Bot lines)
+- Deep source-tree exploration of `src/`, `extensions/`, `docs/`, and config schemas
+- Cross-reference of every OpenClaw feature against Pool Bot codebase using grep/AST search
+
+## Confirmed Present (No Gap)
+
+These OpenClaw features already exist in Pool Bot:
+
+| Feature | Evidence |
+|---------|----------|
+| SSRF protection | 91+ references across `src/infra/net/ssrf.ts` and callers |
+| Draft streaming (Telegram/Discord/Slack) | Full implementation in channel modules |
+| Config validation | 100+ Zod schema matches |
+| Session compaction | Plugin hooks, auto-compaction, diagnostics |
+| Feishu/LINE/Mattermost/IRC/MS Teams/Nextcloud Talk/Tlon | Extensions present |
+| Ollama memory embeddings | v2026.3.4 |
+| Channel auto-restart with exponential backoff | Cherry-picked from OpenClaw |
+| Boundary file read / safe-open-sync | Cherry-picked from OpenClaw |
+| Hardened fs-safe with atomic writes | Cherry-picked from OpenClaw |
+
+## Confirmed Missing — Critical & High Priority
+
+### 1. HTTP Container Health Probes
+
+**Priority:** Critical | **Effort:** S (small)
+
+OpenClaw 2026.3.1 added built-in HTTP liveness/readiness endpoints (`/health`, `/healthz`, `/ready`, `/readyz`) for Docker/Kubernetes orchestrators. Pool Bot's gateway has WS-based health only — no HTTP endpoint paths for container probes.
+
+**Impact:** Blocks production Kubernetes/Docker deployments from proper health checking.
+
+### 2. First-class PDF Tool
+
+**Priority:** High | **Effort:** M (medium)
+
+OpenClaw 2026.3.2 added a native PDF document extraction tool using provider-native document understanding (Anthropic/Google). Pool Bot's browser-tool has a "pdf" action that renders pages to PDF via browser, but no dedicated extraction tool.
+
+**Impact:** Users cannot extract text/data from PDF documents using provider-native capabilities.
+
+### 3. Cron Failure Alerts
+
+**Priority:** High | **Effort:** L (large)
+
+OpenClaw 2026.3.1 added `failureAlert.mode` (announce | webhook) with `failureAlert.accountId`, per-job `delivery.failureDestination`. OpenClaw 2026.3.3 extended this with repeated-failure alerting, per-job overrides, and Web UI editor support. Pool Bot's cron logs failures but has no notification mechanism.
+
+**Impact:** Operators have no way to be notified when scheduled tasks fail.
+
+### 4. Tools/Diffs Plugin
+
+**Priority:** High | **Effort:** M (medium)
+
+OpenClaw 2026.3.1 added a `diffs` plugin tool for read-only diff rendering from before/after text or unified patches, with gateway viewer URLs. OpenClaw 2026.3.2 added PDF output support.
+
+**Impact:** Agents cannot present structured diffs to users in a readable format.
+
+### 5. Head+Tail Truncation Strategy
+
+**Priority:** Medium | **Effort:** S (small)
+
+OpenClaw added head+tail truncation for long messages — keeping the beginning and end of messages while eliding the middle. Pool Bot only has simple character-limit truncation.
+
+**Impact:** Long responses lose valuable ending content when truncated.
+
+## Confirmed Missing — Medium Priority
+
+| Feature | OpenClaw Version | Effort |
+|---------|-----------------|--------|
+| Perplexity Search API integration | 2026.2.14 | M |
+| Telegram per-topic agentId | 2026.2.25 | S |
+| Slack DM typing indicators | 2026.2.28 | S |
+| Discord `allowBots` flag | 2026.2.28 | S |
+| `config validate` CLI command | 2026.3.1 | S |
+| OpenAI Responses WS transport | 2026.3.1 | L |
+| Discord thread binding lifecycle | 2026.3.1 | M |
+| Telegram DM topics | 2026.3.1 | S |
+| Plugin runtime API enhancements | 2026.3.2 | M |
+| Adaptive thinking budget | 2026.3.2 | M |
+| Gateway Permissions-Policy header | 2026.3.2 | S |
+| Config heartbeat auto-migration | 2026.3.3 | S |
+
+## Confirmed Missing — Low Priority
+
+| Feature | OpenClaw Version | Effort |
+|---------|-----------------|--------|
+| CLI banner tagline randomizer | 2026.2.14 | S |
+| `config file` command | 2026.3.1 | S |
+| Web UI locale additions | 2026.3.2 | S |
+| SecretRef/Secrets management | 2026.3.1-3.3 | XL |
+
+## Recommended Implementation Order
+
+1. **HTTP Health Probes** — smallest effort, unblocks container orchestration
+2. **Head+tail truncation** — small effort, immediate UX improvement
+3. **Cron failure alerts** — high operator value, moderate effort
+4. **First-class PDF tool** — high user value, leverages existing patterns
+5. **Diffs plugin tool** — complements agent capabilities
+6. **SecretRef system** — XL effort, defer to dedicated sprint
+
+## Decision
+
+Implement items 1-5 in a single feature batch. Defer SecretRef and medium/low items to subsequent releases.