@poolzin/pool-bot 2026.4.2 → 2026.4.3

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "2026.4.2",
-  "commit": "8eeca02c4b2495703b20bcee46e40f1a789d84f2",
-  "builtAt": "2026-03-24T16:56:28.110Z"
+  "version": "2026.4.3",
+  "commit": "1efd55a199a48550713859fd4bd39bd1901a9d20",
+  "builtAt": "2026-03-24T22:39:33.772Z"
 }

package/dist/gateway/server-startup-matrix-migration.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Server Startup Matrix Migration
+ * Handles Matrix channel state migrations during gateway startup.
+ */
+type MigrationLogger = {
+    info?: (message: string) => void;
+    warn?: (message: string) => void;
+};
+export declare function runStartupMatrixMigration(params: {
+    cfg?: Record<string, unknown>;
+    env?: NodeJS.ProcessEnv;
+    log: MigrationLogger;
+    trigger?: string;
+}): Promise<void>;
+export {};
+//# sourceMappingURL=server-startup-matrix-migration.d.ts.map

package/dist/gateway/server-startup-matrix-migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-startup-matrix-migration.d.ts","sourceRoot":"","sources":["../../src/gateway/server-startup-matrix-migration.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,KAAK,eAAe,GAAG;IACrB,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CAClC,CAAC;AAEF,wBAAsB,yBAAyB,CAAC,MAAM,EAAE;IACtD,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,GAAG,EAAE,eAAe,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GAAG,OAAO,CAAC,IAAI,CAAC,CA8BhB"}

package/dist/gateway/server-startup-matrix-migration.js

@@ -0,0 +1,29 @@
+/**
+ * Server Startup Matrix Migration
+ * Handles Matrix channel state migrations during gateway startup.
+ */
+export async function runStartupMatrixMigration(params) {
+    const logPrefix = "gateway";
+    const trigger = params.trigger?.trim() || "gateway-startup";
+    // Check if Matrix is configured
+    const cfg = params.cfg ?? {};
+    const matrixCfg = cfg.matrix;
+    if (!matrixCfg?.enabled) {
+        return;
+    }
+    params.log.info?.(`${logPrefix}: matrix migration check (trigger=${trigger})`);
+    // Best-effort migration steps
+    const steps = [
+        { label: "legacy Matrix state migration", fn: async () => { } },
+        { label: "legacy Matrix crypto preparation", fn: async () => { } },
+    ];
+    for (const step of steps) {
+        try {
+            await step.fn();
+        }
+        catch (err) {
+            params.log.warn?.(`${logPrefix}: ${step.label} failed during Matrix migration; continuing startup: ${String(err)}`);
+        }
+    }
+    params.log.info?.(`${logPrefix}: Matrix migration check complete`);
+}

package/dist/gateway/session-archive.fs.d.ts

@@ -0,0 +1,19 @@
+export type ArchiveReason = "reset" | "deleted";
+export declare function archiveFileOnDisk(filePath: string, reason: ArchiveReason): string;
+export declare function archiveSessionTranscripts(opts: {
+    sessionId: string;
+    storePath?: string;
+    sessionFile?: string;
+    agentId?: string;
+    reason: ArchiveReason;
+}): string[];
+export declare function cleanupArchivedSessionTranscripts(opts: {
+    directories: string[];
+    olderThanMs: number;
+    reason?: ArchiveReason;
+    nowMs?: number;
+}): Promise<{
+    removed: number;
+    scanned: number;
+}>;
+//# sourceMappingURL=session-archive.fs.d.ts.map

package/dist/gateway/session-archive.fs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-archive.fs.d.ts","sourceRoot":"","sources":["../../src/gateway/session-archive.fs.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,SAAS,CAAC;AA+BhD,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,GAAG,MAAM,CAKjF;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE;IAC9C,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,aAAa,CAAC;CACvB,GAAG,MAAM,EAAE,CA6BX;AAED,wBAAsB,iCAAiC,CAAC,IAAI,EAAE;IAC5D,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,GAAG,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAmChD"}

package/dist/gateway/session-archive.fs.js

@@ -0,0 +1,111 @@
+/**
+ * Session Archive FS
+ * Handles archiving and cleanup of session transcript files on disk.
+ */
+import fs from "node:fs";
+import path from "node:path";
+function formatArchiveTimestamp() {
+    return new Date().toISOString().replace(/[:.]/g, "-");
+}
+function parseArchiveTimestamp(entry, reason) {
+    const suffix = `.${reason}.`;
+    const idx = entry.lastIndexOf(suffix);
+    if (idx < 0)
+        return null;
+    const tsPart = entry.slice(idx + suffix.length);
+    const iso = tsPart.replace(/-/g, (m, offset) => {
+        if (offset === 4 || offset === 7)
+            return "-";
+        if (offset === 10)
+            return "T";
+        if (offset === 13 || offset === 16)
+            return ":";
+        if (offset === 19)
+            return ".";
+        return m;
+    });
+    const ts = new Date(iso).getTime();
+    return Number.isFinite(ts) ? ts : null;
+}
+function canonicalizePath(filePath) {
+    const resolved = path.resolve(filePath);
+    try {
+        return fs.realpathSync(resolved);
+    }
+    catch {
+        return resolved;
+    }
+}
+export function archiveFileOnDisk(filePath, reason) {
+    const ts = formatArchiveTimestamp();
+    const archived = `${filePath}.${reason}.${ts}`;
+    fs.renameSync(filePath, archived);
+    return archived;
+}
+export function archiveSessionTranscripts(opts) {
+    const archived = [];
+    const candidates = [];
+    // Gather candidate paths
+    if (opts.storePath) {
+        const sessionsDir = path.dirname(opts.storePath);
+        if (opts.sessionFile) {
+            candidates.push(path.resolve(sessionsDir, opts.sessionFile));
+        }
+        candidates.push(path.resolve(sessionsDir, `${opts.sessionId}.jsonl`));
+    }
+    if (opts.agentId) {
+        const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+        candidates.push(path.resolve(home, ".poolbot", "agents", opts.agentId, "sessions", `${opts.sessionId}.jsonl`));
+    }
+    const unique = Array.from(new Set(candidates.map(canonicalizePath)));
+    for (const candidate of unique) {
+        if (!fs.existsSync(candidate))
+            continue;
+        try {
+            archived.push(archiveFileOnDisk(candidate, opts.reason));
+        }
+        catch {
+            // Best-effort
+        }
+    }
+    return archived;
+}
+export async function cleanupArchivedSessionTranscripts(opts) {
+    if (!Number.isFinite(opts.olderThanMs) || opts.olderThanMs < 0) {
+        return { removed: 0, scanned: 0 };
+    }
+    const now = opts.nowMs ?? Date.now();
+    const reason = opts.reason ?? "deleted";
+    const directories = Array.from(new Set(opts.directories.map((dir) => path.resolve(dir))));
+    let removed = 0;
+    let scanned = 0;
+    for (const dir of directories) {
+        let entries;
+        try {
+            entries = await fs.promises.readdir(dir);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const timestamp = parseArchiveTimestamp(entry, reason);
+            if (timestamp == null)
+                continue;
+            scanned++;
+            if (now - timestamp <= opts.olderThanMs)
+                continue;
+            const fullPath = path.join(dir, entry);
+            try {
+                const stat = await fs.promises.stat(fullPath);
+                if (stat.isFile()) {
+                    await fs.promises.rm(fullPath);
+                    removed++;
+                }
+            }
+            catch {
+                // Best-effort
+            }
+        }
+    }
+    return { removed, scanned };
+}

package/dist/gateway/sessions-history-http.d.ts

@@ -1,10 +1,8 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
-import type { AuthRateLimiter } from "./auth-rate-limit.js";
-import { type ResolvedGatewayAuth } from "./auth.js";
 export declare function handleSessionHistoryHttpRequest(req: IncomingMessage, res: ServerResponse, opts: {
-    auth: ResolvedGatewayAuth;
-    trustedProxies?: string[];
-    allowRealIpFallback?: boolean;
-    rateLimiter?: AuthRateLimiter;
+    auth?: {
+        token?: string;
+    };
+    sessionsStorePath?: string;
 }): Promise<boolean>;
 //# sourceMappingURL=sessions-history-http.d.ts.map

package/dist/gateway/sessions-history-http.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sessions-history-http.d.ts","sourceRoot":"","sources":["../../src/gateway/sessions-history-http.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAKjE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAA+B,KAAK,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAgIlF,wBAAsB,+BAA+B,CACnD,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,cAAc,EACnB,IAAI,EAAE;IACJ,IAAI,EAAE,mBAAmB,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,WAAW,CAAC,EAAE,eAAe,CAAC;CAC/B,GACA,OAAO,CAAC,OAAO,CAAC,CA8IlB"}
+{"version":3,"file":"sessions-history-http.d.ts","sourceRoot":"","sources":["../../src/gateway/sessions-history-http.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAiKjE,wBAAsB,+BAA+B,CACnD,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,cAAc,EACnB,IAAI,EAAE;IACJ,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1B,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,GACA,OAAO,CAAC,OAAO,CAAC,CAqDlB"}

package/dist/gateway/sessions-history-http.js

@@ -1,76 +1,58 @@
+/**
+ * Sessions History HTTP
+ * HTTP handler for retrieving session message history with pagination and SSE streaming.
+ */
 import fs from "node:fs";
 import path from "node:path";
-import { loadConfig } from "../config/config.js";
-import { loadSessionStore } from "../config/sessions.js";
-import { onSessionTranscriptUpdate } from "../sessions/transcript-events.js";
-import { authorizeHttpGatewayConnect } from "./auth.js";
-import { sendGatewayAuthFailure, sendInvalidRequest, sendJson, sendMethodNotAllowed, setSseHeaders, } from "./http-common.js";
-import { getBearerToken, getHeader } from "./http-utils.js";
-import { attachOpenClawTranscriptMeta, readSessionMessages, resolveGatewaySessionStoreTarget, resolveSessionTranscriptCandidates, } from "./session-utils.js";
-const MAX_SESSION_HISTORY_LIMIT = 1000;
-function resolveSessionHistoryPath(req) {
-    const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+const MAX_HISTORY_LIMIT = 1000;
+function parseUrl(req) {
+    return new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+}
+function getHeader(req, name) {
+    const value = req.headers[name.toLowerCase()];
+    return Array.isArray(value) ? value[0] : value;
+}
+function resolveSessionKey(req) {
+    const url = parseUrl(req);
     const match = url.pathname.match(/^\/sessions\/([^/]+)\/history$/);
-    if (!match) {
+    if (!match)
         return null;
-    }
     try {
         return decodeURIComponent(match[1] ?? "").trim() || null;
     }
     catch {
-        return "";
+        return null;
     }
 }
-function shouldStreamSse(req) {
-    const accept = getHeader(req, "accept")?.toLowerCase() ?? "";
-    return accept.includes("text/event-stream");
-}
-function getRequestUrl(req) {
-    return new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
-}
 function resolveLimit(req) {
-    const raw = getRequestUrl(req).searchParams.get("limit");
-    if (raw == null || raw.trim() === "") {
+    const raw = parseUrl(req).searchParams.get("limit");
+    if (!raw?.trim())
         return undefined;
-    }
-    const value = Number.parseInt(raw, 10);
-    if (!Number.isFinite(value) || value < 1) {
+    const value = parseInt(raw, 10);
+    if (!Number.isFinite(value) || value < 1)
         return 1;
-    }
-    return Math.min(MAX_SESSION_HISTORY_LIMIT, Math.max(1, value));
+    return Math.min(MAX_HISTORY_LIMIT, Math.max(1, value));
 }
 function resolveCursor(req) {
-    const raw = getRequestUrl(req).searchParams.get("cursor");
-    const trimmed = raw?.trim();
-    return trimmed ? trimmed : undefined;
+    return parseUrl(req).searchParams.get("cursor")?.trim() || undefined;
 }
 function resolveCursorSeq(cursor) {
-    if (!cursor) {
+    if (!cursor)
         return undefined;
-    }
     const normalized = cursor.startsWith("seq:") ? cursor.slice(4) : cursor;
-    const value = Number.parseInt(normalized, 10);
+    const value = parseInt(normalized, 10);
     return Number.isFinite(value) && value > 0 ? value : undefined;
 }
-function resolveMessageSeq(message) {
-    if (!message || typeof message !== "object" || Array.isArray(message)) {
-        return undefined;
-    }
-    const meta = message.__openclaw;
-    if (!meta || typeof meta !== "object" || Array.isArray(meta)) {
-        return undefined;
-    }
-    const seq = meta.seq;
-    return typeof seq === "number" && Number.isFinite(seq) && seq > 0 ? seq : undefined;
-}
-function paginateSessionMessages(messages, limit, cursor) {
+function paginateMessages(messages, limit, cursor) {
     const cursorSeq = resolveCursorSeq(cursor);
     const endExclusive = typeof cursorSeq === "number"
         ? Math.max(0, Math.min(messages.length, cursorSeq - 1))
         : messages.length;
     const start = typeof limit === "number" && limit > 0 ? Math.max(0, endExclusive - limit) : 0;
     const items = messages.slice(start, endExclusive);
-    const firstSeq = resolveMessageSeq(items[0]);
+    const firstItem = items[0];
+    const meta = firstItem?.__poolbot;
+    const firstSeq = typeof meta?.seq === "number" ? meta.seq : undefined;
     return {
         items,
         messages: items,
@@ -78,135 +60,118 @@ function paginateSessionMessages(messages, limit, cursor) {
         ...(start > 0 && typeof firstSeq === "number" ? { nextCursor: String(firstSeq) } : {}),
     };
 }
-function canonicalizePath(value) {
-    const trimmed = value?.trim();
-    if (!trimmed) {
-        return undefined;
+function readSessionMessages(sessionId, storePath, sessionFile) {
+    let filePath;
+    if (sessionFile) {
+        filePath = path.isAbsolute(sessionFile)
+            ? sessionFile
+            : path.resolve(path.dirname(storePath ?? "."), sessionFile);
+    }
+    else if (storePath) {
+        filePath = path.resolve(path.dirname(storePath), `${sessionId}.jsonl`);
+    }
+    if (!filePath || !fs.existsSync(filePath))
+        return [];
+    try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        return content
+            .split("\n")
+            .filter(Boolean)
+            .map((line) => {
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter(Boolean);
     }
-    const resolved = path.resolve(trimmed);
+    catch {
+        return [];
+    }
+}
+function resolveSessionStore(storePath) {
     try {
-        return fs.realpathSync(resolved);
+        if (fs.existsSync(storePath)) {
+            const content = fs.readFileSync(storePath, "utf-8");
+            return JSON.parse(content);
+        }
     }
     catch {
-        return resolved;
+        // Best-effort
     }
+    return {};
+}
+function findSessionEntry(store, sessionKey) {
+    // Try direct key
+    if (store[sessionKey])
+        return store[sessionKey];
+    // Try matching sessionId
+    for (const entry of Object.values(store)) {
+        if (entry.sessionId === sessionKey)
+            return entry;
+    }
+    return undefined;
+}
+function shouldStreamSse(req) {
+    return (getHeader(req, "accept") ?? "").toLowerCase().includes("text/event-stream");
+}
+function sendJson(res, status, data) {
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(data));
+}
+function sendError(res, status, type, message) {
+    sendJson(res, status, { ok: false, error: { type, message } });
+}
+function setSseHeaders(res) {
+    res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+    });
 }
 function sseWrite(res, event, payload) {
-    res.write(`event: ${event}
-`);
-    res.write(`data: ${JSON.stringify(payload)}
-
-`);
+    res.write(`event: ${event}\n`);
+    res.write(`data: ${JSON.stringify(payload)}\n\n`);
 }
 export async function handleSessionHistoryHttpRequest(req, res, opts) {
-    const sessionKey = resolveSessionHistoryPath(req);
-    if (sessionKey === null) {
+    const sessionKey = resolveSessionKey(req);
+    if (sessionKey === null)
         return false;
-    }
     if (!sessionKey) {
-        sendInvalidRequest(res, "invalid session key");
+        sendError(res, 400, "invalid_request", "invalid session key");
         return true;
     }
     if (req.method !== "GET") {
-        sendMethodNotAllowed(res, "GET");
+        sendError(res, 405, "method_not_allowed", "GET required");
         return true;
     }
-    const cfg = loadConfig();
-    const token = getBearerToken(req);
-    const authResult = await authorizeHttpGatewayConnect({
-        auth: opts.auth,
-        connectAuth: token ? { token, password: token } : null,
-        req,
-        trustedProxies: opts.trustedProxies ?? cfg.gateway?.trustedProxies,
-        allowRealIpFallback: opts.allowRealIpFallback ?? cfg.gateway?.allowRealIpFallback,
-        rateLimiter: opts.rateLimiter,
-    });
-    if (!authResult.ok) {
-        sendGatewayAuthFailure(res, authResult);
-        return true;
-    }
-    const target = resolveGatewaySessionStoreTarget({ cfg, key: sessionKey });
-    const store = loadSessionStore(target.storePath);
-    const entry = target.storeKeys.map((key) => store[key]).find(Boolean);
+    const storePath = opts.sessionsStorePath ?? path.join(process.env.HOME || process.env.USERPROFILE || "/tmp", ".poolbot", "sessions", "sessions.json");
+    const store = resolveSessionStore(storePath);
+    const entry = findSessionEntry(store, sessionKey);
     if (!entry?.sessionId) {
-        sendJson(res, 404, {
-            ok: false,
-            error: {
-                type: "not_found",
-                message: `Session not found: ${sessionKey}`,
-            },
-        });
+        sendError(res, 404, "not_found", `Session not found: ${sessionKey}`);
         return true;
     }
     const limit = resolveLimit(req);
     const cursor = resolveCursor(req);
-    const history = paginateSessionMessages(entry?.sessionId
-        ? readSessionMessages(entry.sessionId, target.storePath, entry.sessionFile)
-        : [], limit, cursor);
+    const messages = readSessionMessages(entry.sessionId, storePath, entry.sessionFile);
+    const history = paginateMessages(messages, limit, cursor);
     if (!shouldStreamSse(req)) {
-        sendJson(res, 200, {
-            sessionKey: target.canonicalKey,
-            ...history,
-        });
+        sendJson(res, 200, { sessionKey, ...history });
         return true;
     }
-    const transcriptCandidates = entry?.sessionId
-        ? new Set(resolveSessionTranscriptCandidates(entry.sessionId, target.storePath, entry.sessionFile, target.agentId)
-            .map((candidate) => canonicalizePath(candidate))
-            .filter((candidate) => typeof candidate === "string"))
-        : new Set();
-    let sentHistory = history;
+    // SSE streaming
     setSseHeaders(res);
-    res.write("retry: 1000, ");, sseWrite(res, "history", {
-        sessionKey: target.canonicalKey,
-        ...sentHistory,
-    }));
+    res.write("retry: 1000\n\n");
+    sseWrite(res, "history", { sessionKey, ...history });
     const heartbeat = setInterval(() => {
         if (!res.writableEnded) {
-            res.write(": keepalive, "););
+            res.write(": keepalive\n\n");
         }
     }, 15_000);
-    const unsubscribe = onSessionTranscriptUpdate((update) => {
-        if (res.writableEnded || !entry?.sessionId) {
-            return;
-        }
-        const updatePath = canonicalizePath(update.sessionFile);
-        if (!updatePath || !transcriptCandidates.has(updatePath)) {
-            return;
-        }
-        if (update.message !== undefined) {
-            const previousSeq = resolveMessageSeq(sentHistory.items.at(-1));
-            const nextMessage = attachOpenClawTranscriptMeta(update.message, {
-                ...(typeof update.messageId === "string" ? { id: update.messageId } : {}),
-                seq: typeof previousSeq === "number"
-                    ? previousSeq + 1
-                    : readSessionMessages(entry.sessionId, target.storePath, entry.sessionFile).length,
-            });
-            if (limit === undefined && cursor === undefined) {
-                sentHistory = {
-                    items: [...sentHistory.items, nextMessage],
-                    messages: [...sentHistory.items, nextMessage],
-                    hasMore: false,
-                };
-                sseWrite(res, "message", {
-                    sessionKey: target.canonicalKey,
-                    message: nextMessage,
-                    ...(typeof update.messageId === "string" ? { messageId: update.messageId } : {}),
-                    messageSeq: resolveMessageSeq(nextMessage),
-                });
-                return;
-            }
-        }
-        sentHistory = paginateSessionMessages(readSessionMessages(entry.sessionId, target.storePath, entry.sessionFile), limit, cursor);
-        sseWrite(res, "history", {
-            sessionKey: target.canonicalKey,
-            ...sentHistory,
-        });
-    });
-    const cleanup = () => {
-        clearInterval(heartbeat);
-        unsubscribe();
-    };
+    const cleanup = () => clearInterval(heartbeat);
     req.on("close", cleanup);
     res.on("close", cleanup);
     res.on("finish", cleanup);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poolzin/pool-bot",
-  "version": "2026.4.2",
+  "version": "2026.4.3",
   "description": "🎱 Pool Bot - AI assistant with PLCODE integrations",
   "keywords": [],
   "license": "MIT",