@poolzin/pool-bot 2026.1.39 → 2026.2.0

package/dist/shared/text/reasoning-tags.js

@@ -1,28 +1,70 @@
 const QUICK_TAG_RE = /<\s*\/?\s*(?:think(?:ing)?|thought|antthinking|final)\b/i;
-const FINAL_TAG_RE = /<\s*\/?\s*final\b[^>]*>/gi;
-const THINKING_TAG_RE = /<\s*(\/?)\s*(?:think(?:ing)?|thought|antthinking)\b[^>]*>/gi;
+const FINAL_TAG_RE = /<\s*\/?\s*final\b[^<>]*>/gi;
+const THINKING_TAG_RE = /<\s*(\/?)\s*(?:think(?:ing)?|thought|antthinking)\b[^<>]*>/gi;
+function findCodeRegions(text) {
+    const regions = [];
+    const fencedRe = /(^|\n)(```|~~~)[^\n]*\n[\s\S]*?(?:\n\2(?:\n|$)|$)/g;
+    for (const match of text.matchAll(fencedRe)) {
+        const start = (match.index ?? 0) + match[1].length;
+        regions.push({ start, end: start + match[0].length - match[1].length });
+    }
+    const inlineRe = /`+[^`]+`+/g;
+    for (const match of text.matchAll(inlineRe)) {
+        const start = match.index ?? 0;
+        const end = start + match[0].length;
+        const insideFenced = regions.some((r) => start >= r.start && end <= r.end);
+        if (!insideFenced) {
+            regions.push({ start, end });
+        }
+    }
+    regions.sort((a, b) => a.start - b.start);
+    return regions;
+}
+function isInsideCode(pos, regions) {
+    return regions.some((r) => pos >= r.start && pos < r.end);
+}
 function applyTrim(value, mode) {
-    if (mode === "none")
+    if (mode === "none") {
         return value;
-    if (mode === "start")
+    }
+    if (mode === "start") {
         return value.trimStart();
+    }
     return value.trim();
 }
 export function stripReasoningTagsFromText(text, options) {
-    if (!text)
+    if (!text) {
         return text;
-    if (!QUICK_TAG_RE.test(text))
+    }
+    if (!QUICK_TAG_RE.test(text)) {
         return text;
+    }
     const mode = options?.mode ?? "strict";
     const trimMode = options?.trim ?? "both";
     let cleaned = text;
     if (FINAL_TAG_RE.test(cleaned)) {
         FINAL_TAG_RE.lastIndex = 0;
-        cleaned = cleaned.replace(FINAL_TAG_RE, "");
+        const finalMatches = [];
+        const preCodeRegions = findCodeRegions(cleaned);
+        for (const match of cleaned.matchAll(FINAL_TAG_RE)) {
+            const start = match.index ?? 0;
+            finalMatches.push({
+                start,
+                length: match[0].length,
+                inCode: isInsideCode(start, preCodeRegions),
+            });
+        }
+        for (let i = finalMatches.length - 1; i >= 0; i--) {
+            const m = finalMatches[i];
+            if (!m.inCode) {
+                cleaned = cleaned.slice(0, m.start) + cleaned.slice(m.start + m.length);
+            }
+        }
     }
     else {
         FINAL_TAG_RE.lastIndex = 0;
     }
+    const codeRegions = findCodeRegions(cleaned);
     THINKING_TAG_RE.lastIndex = 0;
     let result = "";
     let lastIndex = 0;
@@ -30,6 +72,9 @@ export function stripReasoningTagsFromText(text, options) {
     for (const match of cleaned.matchAll(THINKING_TAG_RE)) {
         const idx = match.index ?? 0;
         const isClose = match[1] === "/";
+        if (isInsideCode(idx, codeRegions)) {
+            continue;
+        }
         if (!inThinking) {
             result += cleaned.slice(lastIndex, idx);
             if (!isClose) {

package/dist/tailscale/detect.js

@@ -0,0 +1,146 @@
+import { execSync } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+/**
+ * Check if Tailscale is installed by looking for the binary.
+ */
+async function isTailscaleInstalled() {
+    try {
+        const platform = os.platform();
+        const possiblePaths = [];
+        if (platform === "linux") {
+            possiblePaths.push("/usr/bin/tailscale", "/usr/local/bin/tailscale");
+        }
+        else if (platform === "darwin") {
+            possiblePaths.push("/Applications/Tailscale.app/Contents/MacOS/Tailscale", "/usr/local/bin/tailscale");
+        }
+        else if (platform === "win32") {
+            possiblePaths.push("C:\\Program Files\\Tailscale\\tailscale.exe", "C:\\ProgramData\\chocolatey\\lib\\tailscale\\tools\\tailscale.exe");
+        }
+        for (const binPath of possiblePaths) {
+            try {
+                await fs.access(binPath);
+                return true;
+            }
+            catch {
+                continue;
+            }
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Run tailscale status command and parse output.
+ */
+async function getTailscaleStatus() {
+    try {
+        const platform = os.platform();
+        const binPath = platform === "win32"
+            ? "tailscale.exe"
+            : platform === "darwin"
+                ? "/Applications/Tailscale.app/Contents/MacOS/Tailscale"
+                : "tailscale";
+        const timeout = 5000;
+        const result = execSync(`"${binPath}" status --json`, {
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "pipe"],
+            timeout,
+        });
+        const status = JSON.parse(result.trim());
+        // Extract useful info from Tailscale status JSON
+        const self = status.Self || {};
+        const backendState = status.BackendState || "";
+        return {
+            installed: true,
+            running: backendState === "Running",
+            ip: self.TailscaleIPs?.[0],
+            dnsName: self.DNSName,
+            hostname: self.HostName,
+            tailnet: status.MagicsockName || status.TailnetName,
+            online: self.Online ?? false,
+            canServe: true, // If running, can serve
+            canFunnel: self.Capabilities?.map.includes("funnel") ?? false,
+        };
+    }
+    catch (err) {
+        // If command fails, return minimal info
+        return {
+            installed: await isTailscaleInstalled(),
+            running: false,
+            canServe: false,
+            canFunnel: false,
+            online: false,
+        };
+    }
+}
+/**
+ * Auto-detect Tailscale configuration and recommend settings.
+ *
+ * This is a SAFE detection function - it only reads status and never
+ * modifies configuration. Recommendations are purely advisory.
+ *
+ * @returns Tailscale auto-detection result
+ */
+export async function detectTailscaleConfig() {
+    const info = {
+        installed: await isTailscaleInstalled(),
+        running: false,
+        canServe: false,
+        canFunnel: false,
+        online: false,
+    };
+    if (!info.installed) {
+        return { detected: false };
+    }
+    // Get detailed status if installed
+    const status = await getTailscaleStatus();
+    Object.assign(info, status);
+    // Generate recommendations based on detected state
+    const recommended = info.online
+        ? {
+            mode: info.canFunnel ? "funnel" : "serve",
+            bind: "tailnet",
+            port: 18789,
+            reason: info.canFunnel
+                ? "Tailscale is online and supports funnel (public access)"
+                : "Tailscale is online - use serve for private tailnet access",
+        }
+        : info.running
+            ? {
+                mode: "off",
+                bind: "loopback",
+                port: 18789,
+                reason: "Tailscale is installed but offline - use loopback bind",
+            }
+            : undefined;
+    return {
+        detected: true,
+        info,
+        recommended,
+    };
+}
+/**
+ * Get a human-readable summary of Tailscale detection.
+ */
+export function formatTailscaleDetection(result) {
+    if (!result.detected || !result.info) {
+        return "Tailscale: Not installed";
+    }
+    const { info, recommended } = result;
+    const parts = [];
+    parts.push(`Tailscale: ${info.installed ? "Installed" : "Not installed"}`);
+    parts.push(`Status: ${info.running ? (info.online ? "Online" : "Offline") : "Not running"}`);
+    if (info.online && info.ip) {
+        parts.push(`IP: ${info.ip}`);
+    }
+    if (info.dnsName) {
+        parts.push(`DNS: ${info.dnsName}`);
+    }
+    if (recommended) {
+        parts.push(`\nRecommendation: ${recommended.mode} (${recommended.reason})`);
+    }
+    return parts.join(" | ");
+}

package/dist/telegram/bot-message-context.js

@@ -141,7 +141,7 @@ export const buildTelegramMessageContext = async ({ primaryCtx, allMedia, storeA
                             await withTelegramApiErrorLogging({
                                 operation: "sendMessage",
                                 fn: () => bot.api.sendMessage(chatId, [
-                                    "Moltbot: access not configured.",
+                                    "Poolbot: access not configured.",
                                     "",
                                     `Your Telegram user id: ${telegramUserId}`,
                                     "",

package/dist/test-helpers/workspace.js

@@ -0,0 +1,11 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+export async function makeTempWorkspace(prefix = "poolbot-workspace-") {
+    return fs.mkdtemp(path.join(os.tmpdir(), prefix));
+}
+export async function writeWorkspaceFile(params) {
+    const filePath = path.join(params.dir, params.name);
+    await fs.writeFile(filePath, params.content, "utf-8");
+    return filePath;
+}

package/dist/test-utils/channel-plugins.js

@@ -0,0 +1,82 @@
+import { imessageOutbound } from "../channels/plugins/outbound/imessage.js";
+import { normalizeIMessageHandle } from "../imessage/targets.js";
+export const createTestRegistry = (channels = []) => ({
+    plugins: [],
+    tools: [],
+    hooks: [],
+    typedHooks: [],
+    channels,
+    providers: [],
+    gatewayHandlers: {},
+    httpHandlers: [],
+    httpRoutes: [],
+    cliRegistrars: [],
+    services: [],
+    commands: [],
+    diagnostics: [],
+});
+export const createIMessageTestPlugin = (params) => ({
+    id: "imessage",
+    meta: {
+        id: "imessage",
+        label: "iMessage",
+        selectionLabel: "iMessage (imsg)",
+        docsPath: "/channels/imessage",
+        blurb: "iMessage test stub.",
+        aliases: ["imsg"],
+    },
+    capabilities: { chatTypes: ["direct", "group"], media: true },
+    config: {
+        listAccountIds: () => [],
+        resolveAccount: () => ({}),
+    },
+    status: {
+        collectStatusIssues: (accounts) => accounts.flatMap((account) => {
+            const lastError = typeof account.lastError === "string" ? account.lastError.trim() : "";
+            if (!lastError)
+                return [];
+            return [
+                {
+                    channel: "imessage",
+                    accountId: account.accountId,
+                    kind: "runtime",
+                    message: `Channel error: ${lastError}`,
+                },
+            ];
+        }),
+    },
+    outbound: params?.outbound ?? imessageOutbound,
+    messaging: {
+        targetResolver: {
+            looksLikeId: (raw) => {
+                const trimmed = raw.trim();
+                if (!trimmed)
+                    return false;
+                if (/^(imessage:|sms:|auto:|chat_id:|chat_guid:|chat_identifier:)/i.test(trimmed)) {
+                    return true;
+                }
+                if (trimmed.includes("@"))
+                    return true;
+                return /^\+?\d{3,}$/.test(trimmed);
+            },
+            hint: "<handle|chat_id:ID>",
+        },
+        normalizeTarget: (raw) => normalizeIMessageHandle(raw),
+    },
+});
+export const createOutboundTestPlugin = (params) => ({
+    id: params.id,
+    meta: {
+        id: params.id,
+        label: params.label ?? String(params.id),
+        selectionLabel: params.label ?? String(params.id),
+        docsPath: params.docsPath ?? `/channels/${params.id}`,
+        blurb: "test stub.",
+    },
+    capabilities: params.capabilities ?? { chatTypes: ["direct"] },
+    config: {
+        listAccountIds: () => [],
+        resolveAccount: () => ({}),
+    },
+    outbound: params.outbound,
+});

package/dist/test-utils/ports.js

@@ -0,0 +1,73 @@
+import { createServer } from "node:net";
+import { isMainThread, threadId } from "node:worker_threads";
+async function isPortFree(port) {
+    if (!Number.isFinite(port) || port <= 0 || port > 65535)
+        return false;
+    return await new Promise((resolve) => {
+        const server = createServer();
+        server.once("error", () => resolve(false));
+        server.listen(port, "127.0.0.1", () => {
+            server.close(() => resolve(true));
+        });
+    });
+}
+async function getOsFreePort() {
+    return await new Promise((resolve, reject) => {
+        const server = createServer();
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", () => {
+            const addr = server.address();
+            if (!addr || typeof addr === "string") {
+                server.close();
+                reject(new Error("failed to acquire free port"));
+                return;
+            }
+            const port = addr.port;
+            server.close((err) => (err ? reject(err) : resolve(port)));
+        });
+    });
+}
+let nextTestPortOffset = 0;
+/**
+ * Allocate a deterministic per-worker port block.
+ *
+ * Motivation: many tests spin up gateway + related services that use derived ports
+ * (e.g. +1/+2/+3/+4). If each test just grabs an OS free port, parallel test runs
+ * can collide on derived ports and get flaky EADDRINUSE.
+ */
+export async function getDeterministicFreePortBlock(params) {
+    const offsets = params?.offsets ?? [0, 1, 2, 3, 4];
+    const maxOffset = Math.max(...offsets);
+    const workerIdRaw = process.env.VITEST_WORKER_ID ?? process.env.VITEST_POOL_ID ?? "";
+    const workerId = Number.parseInt(workerIdRaw, 10);
+    const shard = Number.isFinite(workerId)
+        ? Math.max(0, workerId)
+        : isMainThread
+            ? Math.abs(process.pid)
+            : Math.abs(threadId);
+    const rangeSize = 1000;
+    const shardCount = 30;
+    const base = 30_000 + (Math.abs(shard) % shardCount) * rangeSize; // <= 59_999
+    const usable = rangeSize - maxOffset;
+    // Allocate in blocks to avoid derived-port overlaps (e.g. port+3).
+    const blockSize = Math.max(maxOffset + 1, 8);
+    for (let attempt = 0; attempt < usable; attempt += 1) {
+        const start = base + ((nextTestPortOffset + attempt) % usable);
+        // eslint-disable-next-line no-await-in-loop
+        const ok = (await Promise.all(offsets.map((offset) => isPortFree(start + offset)))).every(Boolean);
+        if (!ok)
+            continue;
+        nextTestPortOffset = (nextTestPortOffset + attempt + blockSize) % usable;
+        return start;
+    }
+    // Fallback: let the OS pick a port block (best effort).
+    for (let attempt = 0; attempt < 25; attempt += 1) {
+        // eslint-disable-next-line no-await-in-loop
+        const port = await getOsFreePort();
+        // eslint-disable-next-line no-await-in-loop
+        const ok = (await Promise.all(offsets.map((offset) => isPortFree(port + offset)))).every(Boolean);
+        if (ok)
+            return port;
+    }
+    throw new Error("failed to acquire a free port block");
+}

package/dist/utils/shell-argv.js

@@ -0,0 +1,61 @@
+export function splitShellArgs(raw) {
+    const tokens = [];
+    let buf = "";
+    let inSingle = false;
+    let inDouble = false;
+    let escaped = false;
+    const pushToken = () => {
+        if (buf.length > 0) {
+            tokens.push(buf);
+            buf = "";
+        }
+    };
+    for (let i = 0; i < raw.length; i += 1) {
+        const ch = raw[i];
+        if (escaped) {
+            buf += ch;
+            escaped = false;
+            continue;
+        }
+        if (!inSingle && !inDouble && ch === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (inSingle) {
+            if (ch === "'") {
+                inSingle = false;
+            }
+            else {
+                buf += ch;
+            }
+            continue;
+        }
+        if (inDouble) {
+            if (ch === '"') {
+                inDouble = false;
+            }
+            else {
+                buf += ch;
+            }
+            continue;
+        }
+        if (ch === "'") {
+            inSingle = true;
+            continue;
+        }
+        if (ch === '"') {
+            inDouble = true;
+            continue;
+        }
+        if (/\s/.test(ch)) {
+            pushToken();
+            continue;
+        }
+        buf += ch;
+    }
+    if (escaped || inSingle || inDouble) {
+        return null;
+    }
+    pushToken();
+    return tokens;
+}

package/dist/utils.js

@@ -243,5 +243,15 @@ export function formatTerminalLink(label, url, opts) {
     }
     return `\u001b]8;;${safeUrl}\u0007${safeLabel}\u001b]8;;\u0007`;
 }
+/**
+ * Strict plain-object check — returns true only for `Object.create(null)` or `{}` literals.
+ * Arrays, Dates, RegExps, class instances, and null/undefined all return false.
+ */
+export function isPlainObject(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
 // Configuration root; can be overridden via CLAWDBOT_STATE_DIR.
 export const CONFIG_DIR = resolveConfigDir();

package/dist/web/qr-image.js

@@ -1,6 +1,6 @@
-import { deflateSync } from "node:zlib";
 import QRCodeModule from "qrcode-terminal/vendor/QRCode/index.js";
 import QRErrorCorrectLevelModule from "qrcode-terminal/vendor/QRCode/QRErrorCorrectLevel.js";
+import { encodePngRgba, fillPixel } from "../media/png-encode.js";
 const QRCode = QRCodeModule;
 const QRErrorCorrectLevel = QRErrorCorrectLevelModule;
 function createQrMatrix(input) {
@@ -9,66 +9,6 @@ function createQrMatrix(input) {
     qr.make();
     return qr;
 }
-function fillPixel(buf, x, y, width, r, g, b, a = 255) {
-    const idx = (y * width + x) * 4;
-    buf[idx] = r;
-    buf[idx + 1] = g;
-    buf[idx + 2] = b;
-    buf[idx + 3] = a;
-}
-function crcTable() {
-    const table = new Uint32Array(256);
-    for (let i = 0; i < 256; i += 1) {
-        let c = i;
-        for (let k = 0; k < 8; k += 1) {
-            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
-        }
-        table[i] = c >>> 0;
-    }
-    return table;
-}
-const CRC_TABLE = crcTable();
-function crc32(buf) {
-    let crc = 0xffffffff;
-    for (let i = 0; i < buf.length; i += 1) {
-        crc = CRC_TABLE[(crc ^ buf[i]) & 0xff] ^ (crc >>> 8);
-    }
-    return (crc ^ 0xffffffff) >>> 0;
-}
-function pngChunk(type, data) {
-    const typeBuf = Buffer.from(type, "ascii");
-    const len = Buffer.alloc(4);
-    len.writeUInt32BE(data.length, 0);
-    const crc = crc32(Buffer.concat([typeBuf, data]));
-    const crcBuf = Buffer.alloc(4);
-    crcBuf.writeUInt32BE(crc, 0);
-    return Buffer.concat([len, typeBuf, data, crcBuf]);
-}
-function encodePngRgba(buffer, width, height) {
-    const stride = width * 4;
-    const raw = Buffer.alloc((stride + 1) * height);
-    for (let row = 0; row < height; row += 1) {
-        const rawOffset = row * (stride + 1);
-        raw[rawOffset] = 0; // filter: none
-        buffer.copy(raw, rawOffset + 1, row * stride, row * stride + stride);
-    }
-    const compressed = deflateSync(raw);
-    const signature = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
-    const ihdr = Buffer.alloc(13);
-    ihdr.writeUInt32BE(width, 0);
-    ihdr.writeUInt32BE(height, 4);
-    ihdr[8] = 8; // bit depth
-    ihdr[9] = 6; // color type RGBA
-    ihdr[10] = 0; // compression
-    ihdr[11] = 0; // filter
-    ihdr[12] = 0; // interlace
-    return Buffer.concat([
-        signature,
-        pngChunk("IHDR", ihdr),
-        pngChunk("IDAT", compressed),
-        pngChunk("IEND", Buffer.alloc(0)),
-    ]);
-}
 export async function renderQrPngBase64(input, opts = {}) {
     const { scale = 6, marginModules = 4 } = opts;
     const qr = createQrMatrix(input);

package/dist/wizard/onboarding.finalize.js

@@ -269,8 +269,8 @@ export async function finalizeOnboardingWizard(options) {
             await prompter.note([
                 `Dashboard link (with token): ${authedUrl}`,
                 controlUiOpened
-                    ? "Opened in your browser. Keep that tab to control Moltbot."
-                    : "Copy/paste this URL in a browser on this machine to control Moltbot.",
+                    ? "Opened in your browser. Keep that tab to control Poolbot."
+                    : "Copy/paste this URL in a browser on this machine to control Poolbot.",
                 controlUiOpenHint,
             ]
                 .filter(Boolean)
@@ -314,8 +314,8 @@ export async function finalizeOnboardingWizard(options) {
         await prompter.note([
             `Dashboard link (with token): ${authedUrl}`,
             controlUiOpened
-                ? "Opened in your browser. Keep that tab to control Moltbot."
-                : "Copy/paste this URL in a browser on this machine to control Moltbot.",
+                ? "Opened in your browser. Keep that tab to control Poolbot."
+                : "Copy/paste this URL in a browser on this machine to control Poolbot.",
             controlUiOpenHint,
         ]
             .filter(Boolean)
@@ -336,7 +336,7 @@ export async function finalizeOnboardingWizard(options) {
         : [
             "If you want your agent to be able to search the web, you’ll need an API key.",
             "",
-            "Moltbot uses Brave Search for the `web_search` tool. Without a Brave Search API key, web search won’t work.",
+            "Poolbot uses Brave Search for the `web_search` tool. Without a Brave Search API key, web search won’t work.",
             "",
             "Set it up interactively:",
             `- Run: ${formatCliCommand("poolbot configure --section web")}`,
@@ -347,8 +347,8 @@ export async function finalizeOnboardingWizard(options) {
         ].join("\n"), "Web search (optional)");
     await prompter.note('What now: https://molt.bot/showcase ("What People Are Building").', "What now");
     await prompter.outro(controlUiOpened
-        ? "Onboarding complete. Dashboard opened with your token; keep that tab to control Moltbot."
+        ? "Onboarding complete. Dashboard opened with your token; keep that tab to control Poolbot."
         : seededInBackground
             ? "Onboarding complete. Web UI seeded in the background; open it anytime with the tokenized link above."
-            : "Onboarding complete. Use the tokenized dashboard link above to control Moltbot.");
+            : "Onboarding complete. Use the tokenized dashboard link above to control Poolbot.");
 }

package/dist/wizard/onboarding.js

@@ -22,11 +22,11 @@ async function requireRiskAcknowledgement(params) {
     await params.prompter.note([
         "Security warning — please read.",
         "",
-        "Moltbot is a hobby project and still in beta. Expect sharp edges.",
+        "Poolbot is a hobby project and still in beta. Expect sharp edges.",
         "This bot can read files and run actions if tools are enabled.",
         "A bad prompt can trick it into doing unsafe things.",
         "",
-        "If you’re not comfortable with basic security and access control, don’t run Moltbot.",
+        "If you’re not comfortable with basic security and access control, don’t run Poolbot.",
         "Ask someone experienced to help before enabling tools or exposing it to the internet.",
         "",
         "Recommended baseline:",
@@ -51,7 +51,7 @@ async function requireRiskAcknowledgement(params) {
 }
 export async function runOnboardingWizard(opts, runtime = defaultRuntime, prompter) {
     printWizardHeader(runtime);
-    await prompter.intro("Moltbot onboarding");
+    await prompter.intro("Poolbot onboarding");
     await requireRiskAcknowledgement({ opts, prompter });
     const snapshot = await readConfigFileSnapshot();
     let baseConfig = snapshot.valid ? snapshot.config : {};

package/docs/RELEASE_WORKFOTS_COMPARISON.md

@@ -5,7 +5,7 @@
 Existem **dois workflows de release** diferentes no pool-bot:
 
 ### 1. `release.yml` - Binários CLI
-- **O que faz:** Gera binários standalone do Moltbot CLI
+- **O que faz:** Gera binários standalone do Poolbot CLI
 - **Ferramenta:** `pkg`
 - **Saída:**
   - Windows: `poolbot-win-x64.exe` (CLI)
@@ -38,13 +38,13 @@ Existem **dois workflows de release** diferentes no pool-bot:
 ## Quando Usar Cada Workflow
 
 ### release.yml (CLI)
-- Quando você quer instalar o Moltbot como ferramenta de CLI
+- Quando você quer instalar o Poolbot como ferramenta de CLI
 - Quando você quer executar `poolbot gateway`, `poolbot tui`, etc.
 - Quando você quer integrar em scripts de automação
 - Para desenvolvedores e usuários técnicos
 
 ### release-apps.yml (Apps)
-- Quando você quer usar o Moltbot como app normal
+- Quando você quer usar o Poolbot como app normal
 - Quando você quer notificações nativas no Windows
 - Quando você quer Canvas, Chat e Camera no Android
 - Para usuários finais, não técnicos

package/docs/_config.yml

@@ -1,4 +1,4 @@
-title: "Moltbot Docs"
+title: "Poolbot Docs"
 description: "A TypeScript/Node gateway + macOS/iOS/Android companions for WhatsApp (web) and Telegram (bot)."
 markdown: kramdown
 highlighter: rouge
@@ -22,7 +22,7 @@ defaults:
 nav:
   - title: "Home"
     url: "/"
-  - title: "Moltbot Assistant"
+  - title: "Poolbot Assistant"
     url: "/start/clawd/"
   - title: "Gateway"
     url: "/gateway/"