@poolzin/pool-bot 2026.1.39 → 2026.2.0

package/dist/hooks/hooks-status.js

@@ -16,7 +16,7 @@ function normalizeInstallOptions(entry) {
         let label = (spec.label ?? "").trim();
         if (!label) {
             if (spec.kind === "bundled") {
-                label = "Bundled with Moltbot";
+                label = "Bundled with Poolbot";
             }
             else if (spec.kind === "npm" && spec.package) {
                 label = `Install ${spec.package} (npm)`;

package/dist/hooks/install.js

@@ -23,7 +23,7 @@ export function resolveHookInstallDir(hookId, hooksDir) {
     const hooksBase = hooksDir ? resolveUserPath(hooksDir) : path.join(CONFIG_DIR, "hooks");
     return path.join(hooksBase, safeDirName(hookId));
 }
-async function ensureMoltbotHooks(manifest) {
+async function ensurePoolbotHooks(manifest) {
     const hooks = manifest.poolbot?.hooks ?? manifest[LEGACY_MANIFEST_KEY]?.hooks;
     if (!Array.isArray(hooks)) {
         throw new Error("package.json missing poolbot.hooks");
@@ -72,7 +72,7 @@ async function installHookPackageFromDir(params) {
     }
     let hookEntries;
     try {
-        hookEntries = await ensureMoltbotHooks(manifest);
+        hookEntries = await ensurePoolbotHooks(manifest);
     }
     catch (err) {
         return { ok: false, error: String(err) };

package/dist/hooks/loader.js

@@ -17,7 +17,7 @@ import { shouldIncludeHook } from "./config.js";
  * 1. Directory-based discovery (bundled, managed, workspace)
  * 2. Legacy config handlers (backwards compatibility)
  *
- * @param cfg - Moltbot configuration
+ * @param cfg - Poolbot configuration
  * @param workspaceDir - Workspace directory for hook discovery
  * @returns Number of handlers successfully loaded
  *

package/dist/hooks/workspace.js

@@ -4,7 +4,7 @@ import { LEGACY_MANIFEST_KEY } from "../compat/legacy-names.js";
 import { CONFIG_DIR, resolveUserPath } from "../utils.js";
 import { resolveBundledHooksDir } from "./bundled-dir.js";
 import { shouldIncludeHook } from "./config.js";
-import { parseFrontmatter, resolveMoltbotMetadata, resolveHookInvocationPolicy, } from "./frontmatter.js";
+import { parseFrontmatter, resolvePoolbotMetadata, resolveHookInvocationPolicy, } from "./frontmatter.js";
 function filterHookEntries(entries, config, eligibility) {
     return entries.filter((entry) => shouldIncludeHook({ entry, config, eligibility }));
 }
@@ -128,7 +128,7 @@ export function loadHookEntriesFromDir(params) {
                 pluginId: params.pluginId,
             },
             frontmatter,
-            metadata: resolveMoltbotMetadata(frontmatter),
+            metadata: resolvePoolbotMetadata(frontmatter),
             invocation: resolveHookInvocationPolicy(frontmatter),
         };
         return entry;
@@ -185,7 +185,7 @@ function loadHookEntries(workspaceDir, opts) {
         return {
             hook,
             frontmatter,
-            metadata: resolveMoltbotMetadata(frontmatter),
+            metadata: resolvePoolbotMetadata(frontmatter),
             invocation: resolveHookInvocationPolicy(frontmatter),
         };
     });

package/dist/index.js

@@ -13,7 +13,7 @@ import { ensureBinary } from "./infra/binaries.js";
 import { loadDotEnv } from "./infra/dotenv.js";
 import { normalizeEnv } from "./infra/env.js";
 import { isMainModule } from "./infra/is-main.js";
-import { ensureMoltbotCliOnPath } from "./infra/path-env.js";
+import { ensurePoolbotCliOnPath } from "./infra/path-env.js";
 import { describePortOwner, ensurePortAvailable, handlePortError, PortInUseError, } from "./infra/ports.js";
 import { assertSupportedRuntime } from "./infra/runtime-guard.js";
 import { formatUncaughtError } from "./infra/errors.js";
@@ -23,7 +23,7 @@ import { runCommandWithTimeout, runExec } from "./process/exec.js";
 import { assertWebChannel, normalizeE164, toWhatsappJid } from "./utils.js";
 loadDotEnv({ quiet: true });
 normalizeEnv();
-ensureMoltbotCliOnPath();
+ensurePoolbotCliOnPath();
 // Capture all console output into structured logs while keeping stdout/stderr behavior.
 enableConsoleCapture();
 // Enforce the minimum supported runtime before doing any work.

package/dist/infra/bonjour.js

@@ -16,11 +16,11 @@ function isDisabledByEnv() {
 }
 function safeServiceName(name) {
     const trimmed = name.trim();
-    return trimmed.length > 0 ? trimmed : "Moltbot";
+    return trimmed.length > 0 ? trimmed : "Poolbot";
 }
 function prettifyInstanceName(name) {
     const normalized = name.trim().replace(/\s+/g, " ");
-    return normalized.replace(/\s+\(Moltbot\)\s*$/i, "").trim() || normalized;
+    return normalized.replace(/\s+\(Poolbot\)\s*$/i, "").trim() || normalized;
 }
 function serviceSummary(label, svc) {
     let fqdn = "unknown";
@@ -63,7 +63,7 @@ export async function startGatewayBonjourAdvertiser(opts) {
         .trim() || "poolbot";
     const instanceName = typeof opts.instanceName === "string" && opts.instanceName.trim()
         ? opts.instanceName.trim()
-        : `${hostname} (Moltbot)`;
+        : `${hostname} (Poolbot)`;
     const displayName = prettifyInstanceName(instanceName);
     const txtBase = {
         role: "gateway",

package/dist/infra/path-env.js

@@ -45,8 +45,8 @@ function candidateBinDirs(opts) {
     // Bundled macOS app: `poolbot` lives next to the executable (process.execPath).
     try {
         const execDir = path.dirname(execPath);
-        const siblingMoltbot = path.join(execDir, "poolbot");
-        if (isExecutable(siblingMoltbot))
+        const siblingPoolbot = path.join(execDir, "poolbot");
+        if (isExecutable(siblingPoolbot))
             candidates.push(execDir);
     }
     catch {
@@ -79,7 +79,7 @@ function candidateBinDirs(opts) {
  * Best-effort PATH bootstrap so skills that require the `poolbot` CLI can run
  * under launchd/minimal environments (and inside the macOS app bundle).
  */
-export function ensureMoltbotCliOnPath(opts = {}) {
+export function ensurePoolbotCliOnPath(opts = {}) {
     if (isTruthyEnvValue(process.env.CLAWDBOT_PATH_BOOTSTRAPPED))
         return;
     process.env.CLAWDBOT_PATH_BOOTSTRAPPED = "1";

package/dist/infra/provider-usage.fetch.minimax.js

@@ -260,7 +260,7 @@ export async function fetchMinimaxUsage(apiKey, timeoutMs, fetchFn) {
         headers: {
             Authorization: `Bearer ${apiKey}`,
             "Content-Type": "application/json",
-            "MM-API-Source": "Moltbot",
+            "MM-API-Source": "Poolbot",
         },
     }, timeoutMs, fetchFn);
     if (!res.ok) {

package/dist/infra/restart.js

@@ -71,7 +71,7 @@ function normalizeSystemdUnit(raw, profile) {
     }
     return unit.endsWith(".service") ? unit : `${unit}.service`;
 }
-export function triggerMoltbotRestart() {
+export function triggerPoolbotRestart() {
     if (process.env.VITEST || process.env.NODE_ENV === "test") {
         return { ok: true, method: "supervisor", detail: "test mode" };
     }

package/dist/infra/tailscale.js

@@ -263,7 +263,7 @@ export async function ensureFunnel(port, exec = runExec, runtime = defaultRuntim
             console.error(warn("Tailscale client/server version mismatch detected; try updating tailscale/tailscaled."));
         }
         runtime.error("Failed to enable Tailscale Funnel. Is it allowed on your tailnet?");
-        runtime.error(info(`Tip: Funnel is optional for Moltbot. You can keep running the web gateway without it: \`${formatCliCommand("poolbot gateway")}\``));
+        runtime.error(info(`Tip: Funnel is optional for Poolbot. You can keep running the web gateway without it: \`${formatCliCommand("poolbot gateway")}\``));
         if (shouldLogVerbose()) {
             const rich = isRich();
             if (stdout.trim()) {

package/dist/macos/relay.js

@@ -37,8 +37,8 @@ async function main() {
     await patchBunLongForProtobuf();
     const { loadDotEnv } = await import("../infra/dotenv.js");
     loadDotEnv({ quiet: true });
-    const { ensureMoltbotCliOnPath } = await import("../infra/path-env.js");
-    ensureMoltbotCliOnPath();
+    const { ensurePoolbotCliOnPath } = await import("../infra/path-env.js");
+    ensurePoolbotCliOnPath();
     const { enableConsoleCapture } = await import("../logging.js");
     enableConsoleCapture();
     const { assertSupportedRuntime } = await import("../infra/runtime-guard.js");

package/dist/media/input-files.js

@@ -78,7 +78,7 @@ export async function fetchWithGuard(params) {
             try {
                 const response = await fetch(parsedUrl, {
                     signal: controller.signal,
-                    headers: { "User-Agent": "Moltbot-Gateway/1.0" },
+                    headers: { "User-Agent": "Poolbot-Gateway/1.0" },
                     redirect: "manual",
                     dispatcher,
                 });

package/dist/media/mime.js

@@ -11,7 +11,10 @@ const EXT_BY_MIME = {
     "image/gif": ".gif",
     "audio/ogg": ".ogg",
     "audio/mpeg": ".mp3",
+    "audio/x-m4a": ".m4a",
+    "audio/mp4": ".m4a",
     "video/mp4": ".mp4",
+    "video/quicktime": ".mov",
     "application/pdf": ".pdf",
     "application/json": ".json",
     "application/zip": ".zip",
@@ -43,6 +46,7 @@ const AUDIO_FILE_EXTENSIONS = new Set([
     ".ogg",
     ".opus",
     ".wav",
+    ".caf",
 ]);
 function normalizeHeaderMime(mime) {
     if (!mime)

package/dist/media/png-encode.js

@@ -0,0 +1,74 @@
+/**
+ * Minimal PNG encoder for generating simple RGBA images without native dependencies.
+ * Used for QR codes, live probes, and other programmatic image generation.
+ */
+import { deflateSync } from "node:zlib";
+const CRC_TABLE = (() => {
+    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;
+})();
+/** Compute CRC32 checksum for a buffer (used in PNG chunk encoding). */
+export 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;
+}
+/** Create a PNG chunk with type, data, and CRC. */
+export 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]);
+}
+/** Write a pixel to an RGBA buffer. Ignores out-of-bounds writes. */
+export function fillPixel(buf, x, y, width, r, g, b, a = 255) {
+    if (x < 0 || y < 0 || x >= width) {
+        return;
+    }
+    const idx = (y * width + x) * 4;
+    if (idx < 0 || idx + 3 >= buf.length) {
+        return;
+    }
+    buf[idx] = r;
+    buf[idx + 1] = g;
+    buf[idx + 2] = b;
+    buf[idx + 3] = a;
+}
+/** Encode an RGBA buffer as a PNG image. */
+export 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)),
+    ]);
+}

package/dist/media-understanding/providers/image.js

@@ -1,11 +1,11 @@
 import { complete } from "@mariozechner/pi-ai";
 import { discoverAuthStorage, discoverModels } from "@mariozechner/pi-coding-agent";
 import { getApiKeyForModel, requireApiKey } from "../../agents/model-auth.js";
-import { ensureMoltbotModelsJson } from "../../agents/models-config.js";
+import { ensurePoolbotModelsJson } from "../../agents/models-config.js";
 import { minimaxUnderstandImage } from "../../agents/minimax-vlm.js";
 import { coerceImageAssistantText } from "../../agents/tools/image-tool.helpers.js";
 export async function describeImageWithModel(params) {
-    await ensureMoltbotModelsJson(params.cfg, params.agentDir);
+    await ensurePoolbotModelsJson(params.cfg, params.agentDir);
     const authStorage = discoverAuthStorage(params.agentDir);
     const modelRegistry = discoverModels(authStorage, params.agentDir);
     const model = modelRegistry.find(params.provider, params.model);

package/dist/memory/backend-config.js

@@ -0,0 +1,207 @@
+import path from "node:path";
+import { resolveAgentWorkspaceDir } from "../agents/agent-scope.js";
+import { parseDurationMs } from "../cli/parse-duration.js";
+import { resolveUserPath } from "../utils.js";
+import { splitShellArgs } from "../utils/shell-argv.js";
+const DEFAULT_BACKEND = "builtin";
+const DEFAULT_CITATIONS = "auto";
+const DEFAULT_QMD_INTERVAL = "5m";
+const DEFAULT_QMD_DEBOUNCE_MS = 15_000;
+const DEFAULT_QMD_TIMEOUT_MS = 4_000;
+const DEFAULT_QMD_EMBED_INTERVAL = "60m";
+const DEFAULT_QMD_COMMAND_TIMEOUT_MS = 30_000;
+const DEFAULT_QMD_UPDATE_TIMEOUT_MS = 120_000;
+const DEFAULT_QMD_EMBED_TIMEOUT_MS = 120_000;
+const DEFAULT_QMD_LIMITS = {
+    maxResults: 6,
+    maxSnippetChars: 700,
+    maxInjectedChars: 4_000,
+    timeoutMs: DEFAULT_QMD_TIMEOUT_MS,
+};
+const DEFAULT_QMD_SCOPE = {
+    default: "deny",
+    rules: [
+        {
+            action: "allow",
+            match: { chatType: "direct" },
+        },
+    ],
+};
+function sanitizeName(input) {
+    const lower = input.toLowerCase().replace(/[^a-z0-9-]+/g, "-");
+    const trimmed = lower.replace(/^-+|-+$/g, "");
+    return trimmed || "collection";
+}
+function ensureUniqueName(base, existing) {
+    let name = sanitizeName(base);
+    if (!existing.has(name)) {
+        existing.add(name);
+        return name;
+    }
+    let suffix = 2;
+    while (existing.has(`${name}-${suffix}`)) {
+        suffix += 1;
+    }
+    const unique = `${name}-${suffix}`;
+    existing.add(unique);
+    return unique;
+}
+function resolvePath(raw, workspaceDir) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        throw new Error("path required");
+    }
+    if (trimmed.startsWith("~") || path.isAbsolute(trimmed)) {
+        return path.normalize(resolveUserPath(trimmed));
+    }
+    return path.normalize(path.resolve(workspaceDir, trimmed));
+}
+function resolveIntervalMs(raw) {
+    const value = raw?.trim();
+    if (!value) {
+        return parseDurationMs(DEFAULT_QMD_INTERVAL, { defaultUnit: "m" });
+    }
+    try {
+        return parseDurationMs(value, { defaultUnit: "m" });
+    }
+    catch {
+        return parseDurationMs(DEFAULT_QMD_INTERVAL, { defaultUnit: "m" });
+    }
+}
+function resolveEmbedIntervalMs(raw) {
+    const value = raw?.trim();
+    if (!value) {
+        return parseDurationMs(DEFAULT_QMD_EMBED_INTERVAL, { defaultUnit: "m" });
+    }
+    try {
+        return parseDurationMs(value, { defaultUnit: "m" });
+    }
+    catch {
+        return parseDurationMs(DEFAULT_QMD_EMBED_INTERVAL, { defaultUnit: "m" });
+    }
+}
+function resolveDebounceMs(raw) {
+    if (typeof raw === "number" && Number.isFinite(raw) && raw >= 0) {
+        return Math.floor(raw);
+    }
+    return DEFAULT_QMD_DEBOUNCE_MS;
+}
+function resolveTimeoutMs(raw, fallback) {
+    if (typeof raw === "number" && Number.isFinite(raw) && raw > 0) {
+        return Math.floor(raw);
+    }
+    return fallback;
+}
+function resolveLimits(raw) {
+    const parsed = { ...DEFAULT_QMD_LIMITS };
+    if (raw?.maxResults && raw.maxResults > 0) {
+        parsed.maxResults = Math.floor(raw.maxResults);
+    }
+    if (raw?.maxSnippetChars && raw.maxSnippetChars > 0) {
+        parsed.maxSnippetChars = Math.floor(raw.maxSnippetChars);
+    }
+    if (raw?.maxInjectedChars && raw.maxInjectedChars > 0) {
+        parsed.maxInjectedChars = Math.floor(raw.maxInjectedChars);
+    }
+    if (raw?.timeoutMs && raw.timeoutMs > 0) {
+        parsed.timeoutMs = Math.floor(raw.timeoutMs);
+    }
+    return parsed;
+}
+function resolveSessionConfig(cfg, workspaceDir) {
+    const enabled = Boolean(cfg?.enabled);
+    const exportDirRaw = cfg?.exportDir?.trim();
+    const exportDir = exportDirRaw ? resolvePath(exportDirRaw, workspaceDir) : undefined;
+    const retentionDays = cfg?.retentionDays && cfg.retentionDays > 0 ? Math.floor(cfg.retentionDays) : undefined;
+    return {
+        enabled,
+        exportDir,
+        retentionDays,
+    };
+}
+function resolveCustomPaths(rawPaths, workspaceDir, existing) {
+    if (!rawPaths?.length) {
+        return [];
+    }
+    const collections = [];
+    rawPaths.forEach((entry, index) => {
+        const trimmedPath = entry?.path?.trim();
+        if (!trimmedPath) {
+            return;
+        }
+        let resolved;
+        try {
+            resolved = resolvePath(trimmedPath, workspaceDir);
+        }
+        catch {
+            return;
+        }
+        const pattern = entry.pattern?.trim() || "**/*.md";
+        const baseName = entry.name?.trim() || `custom-${index + 1}`;
+        const name = ensureUniqueName(baseName, existing);
+        collections.push({
+            name,
+            path: resolved,
+            pattern,
+            kind: "custom",
+        });
+    });
+    return collections;
+}
+function resolveDefaultCollections(include, workspaceDir, existing) {
+    if (!include) {
+        return [];
+    }
+    const entries = [
+        { path: workspaceDir, pattern: "MEMORY.md", base: "memory-root" },
+        { path: workspaceDir, pattern: "memory.md", base: "memory-alt" },
+        { path: path.join(workspaceDir, "memory"), pattern: "**/*.md", base: "memory-dir" },
+    ];
+    return entries.map((entry) => ({
+        name: ensureUniqueName(entry.base, existing),
+        path: entry.path,
+        pattern: entry.pattern,
+        kind: "memory",
+    }));
+}
+export function resolveMemoryBackendConfig(params) {
+    const backend = params.cfg.memory?.backend ?? DEFAULT_BACKEND;
+    const citations = params.cfg.memory?.citations ?? DEFAULT_CITATIONS;
+    if (backend !== "qmd") {
+        return { backend: "builtin", citations };
+    }
+    const workspaceDir = resolveAgentWorkspaceDir(params.cfg, params.agentId);
+    const qmdCfg = params.cfg.memory?.qmd;
+    const includeDefaultMemory = qmdCfg?.includeDefaultMemory !== false;
+    const nameSet = new Set();
+    const collections = [
+        ...resolveDefaultCollections(includeDefaultMemory, workspaceDir, nameSet),
+        ...resolveCustomPaths(qmdCfg?.paths, workspaceDir, nameSet),
+    ];
+    const rawCommand = qmdCfg?.command?.trim() || "qmd";
+    const parsedCommand = splitShellArgs(rawCommand);
+    const command = parsedCommand?.[0] || rawCommand.split(/\s+/)[0] || "qmd";
+    const resolved = {
+        command,
+        collections,
+        includeDefaultMemory,
+        sessions: resolveSessionConfig(qmdCfg?.sessions, workspaceDir),
+        update: {
+            intervalMs: resolveIntervalMs(qmdCfg?.update?.interval),
+            debounceMs: resolveDebounceMs(qmdCfg?.update?.debounceMs),
+            onBoot: qmdCfg?.update?.onBoot !== false,
+            waitForBootSync: qmdCfg?.update?.waitForBootSync === true,
+            embedIntervalMs: resolveEmbedIntervalMs(qmdCfg?.update?.embedInterval),
+            commandTimeoutMs: resolveTimeoutMs(qmdCfg?.update?.commandTimeoutMs, DEFAULT_QMD_COMMAND_TIMEOUT_MS),
+            updateTimeoutMs: resolveTimeoutMs(qmdCfg?.update?.updateTimeoutMs, DEFAULT_QMD_UPDATE_TIMEOUT_MS),
+            embedTimeoutMs: resolveTimeoutMs(qmdCfg?.update?.embedTimeoutMs, DEFAULT_QMD_EMBED_TIMEOUT_MS),
+        },
+        limits: resolveLimits(qmdCfg?.limits),
+        scope: qmdCfg?.scope ?? DEFAULT_QMD_SCOPE,
+    };
+    return {
+        backend: "qmd",
+        citations,
+        qmd: resolved,
+    };
+}

package/dist/memory/embeddings.js

@@ -160,7 +160,7 @@ function formatLocalSetupError(err) {
         "To enable local embeddings:",
         "1) Use Node 22 LTS (recommended for installs/updates)",
         missing
-            ? "2) Reinstall Moltbot (this should install node-llama-cpp): npm i -g poolbot@latest"
+            ? "2) Reinstall Poolbot (this should install node-llama-cpp): npm i -g poolbot@latest"
             : null,
         "3) If you use pnpm: pnpm approve-builds (select node-llama-cpp), then pnpm rebuild node-llama-cpp",
         'Or set agents.defaults.memorySearch.provider = "openai" (remote).',

package/dist/memory/manager.js

@@ -310,6 +310,7 @@ export class MemoryIndexManager {
             return sources.map((source) => ({ source, ...bySource.get(source) }));
         })();
         return {
+            backend: "builtin",
             files: files?.c ?? 0,
             chunks: chunks?.c ?? 0,
             dirty: this.dirty,

package/dist/memory/types.js

@@ -0,0 +1 @@
+export {};

package/dist/node-host/runner.js

@@ -13,7 +13,7 @@ import { createBrowserControlContext, startBrowserControlServiceFromConfig, } fr
 import { createBrowserRouteDispatcher } from "../browser/routes/dispatcher.js";
 import { detectMime } from "../media/mime.js";
 import { resolveAgentConfig } from "../agents/agent-scope.js";
-import { ensureMoltbotCliOnPath } from "../infra/path-env.js";
+import { ensurePoolbotCliOnPath } from "../infra/path-env.js";
 import { VERSION } from "../version.js";
 import { GATEWAY_CLIENT_MODES, GATEWAY_CLIENT_NAMES } from "../utils/message-channel.js";
 import { ensureNodeHostConfig, saveNodeHostConfig } from "./config.js";
@@ -296,7 +296,7 @@ function resolveEnvPath(env) {
     return raw.split(path.delimiter).filter(Boolean);
 }
 function ensureNodePathEnv() {
-    ensureMoltbotCliOnPath({ pathEnv: process.env.PATH ?? "" });
+    ensurePoolbotCliOnPath({ pathEnv: process.env.PATH ?? "" });
     const current = process.env.PATH ?? "";
     if (current.trim())
         return current;

package/dist/pairing/pairing-messages.js

@@ -2,7 +2,7 @@ import { formatCliCommand } from "../cli/command-format.js";
 export function buildPairingReply(params) {
     const { channel, idLine, code } = params;
     return [
-        "Moltbot: access not configured.",
+        "Poolbot: access not configured.",
         "",
         idLine,
         "",

package/dist/plugins/discovery.js

@@ -58,7 +58,7 @@ function addCandidate(params) {
         packageVersion: manifest?.version?.trim() || undefined,
         packageDescription: manifest?.description?.trim() || undefined,
         packageDir: params.packageDir,
-        packageMoltbot: getPackageManifestMetadata(manifest ?? undefined),
+        packagePoolbot: getPackageManifestMetadata(manifest ?? undefined),
     });
 }
 function discoverInDirectory(params) {

package/dist/plugins/install.js

@@ -21,7 +21,7 @@ function safeDirName(input) {
 function safeFileName(input) {
     return safeDirName(input);
 }
-async function ensureMoltbotExtensions(manifest) {
+async function ensurePoolbotExtensions(manifest) {
     const extensions = manifest.poolbot?.extensions ?? manifest[LEGACY_MANIFEST_KEY]?.extensions;
     if (!Array.isArray(extensions)) {
         throw new Error("package.json missing poolbot.extensions");
@@ -56,7 +56,7 @@ async function installPluginFromPackageDir(params) {
     }
     let extensions;
     try {
-        extensions = await ensureMoltbotExtensions(manifest);
+        extensions = await ensurePoolbotExtensions(manifest);
     }
     catch (err) {
         return { ok: false, error: String(err) };

package/dist/plugins/update.js

@@ -26,7 +26,7 @@ function resolveBundledPluginSources(params) {
         const pluginId = manifest.manifest.id;
         if (bundled.has(pluginId))
             continue;
-        const npmSpec = candidate.packageMoltbot?.install?.npmSpec?.trim() ||
+        const npmSpec = candidate.packagePoolbot?.install?.npmSpec?.trim() ||
             candidate.packageName?.trim() ||
             undefined;
         bundled.set(pluginId, {

package/dist/security/audit.js

@@ -65,7 +65,7 @@ async function collectFilesystemFindings(params) {
                 checkId: "fs.state_dir.perms_world_writable",
                 severity: "critical",
                 title: "State dir is world-writable",
-                detail: `${formatPermissionDetail(params.stateDir, stateDirPerms)}; other users can write into your Moltbot state.`,
+                detail: `${formatPermissionDetail(params.stateDir, stateDirPerms)}; other users can write into your Poolbot state.`,
                 remediation: formatPermissionRemediation({
                     targetPath: params.stateDir,
                     perms: stateDirPerms,
@@ -80,7 +80,7 @@ async function collectFilesystemFindings(params) {
                 checkId: "fs.state_dir.perms_group_writable",
                 severity: "warn",
                 title: "State dir is group-writable",
-                detail: `${formatPermissionDetail(params.stateDir, stateDirPerms)}; group users can write into your Moltbot state.`,
+                detail: `${formatPermissionDetail(params.stateDir, stateDirPerms)}; group users can write into your Poolbot state.`,
                 remediation: formatPermissionRemediation({
                     targetPath: params.stateDir,
                     perms: stateDirPerms,