@poolzin/pool-bot 2026.2.2 → 2026.2.4

package/dist/entry.js

@@ -25,13 +25,16 @@ function hasExperimentalWarningSuppressed() {
     return false;
 }
 function ensureExperimentalWarningSuppressed() {
-    if (isTruthyEnvValue(process.env.CLAWDBOT_NO_RESPAWN))
+    if (isTruthyEnvValue(process.env.POOLBOT_NO_RESPAWN) ||
+        isTruthyEnvValue(process.env.CLAWDBOT_NO_RESPAWN))
         return false;
-    if (isTruthyEnvValue(process.env.CLAWDBOT_NODE_OPTIONS_READY))
+    if (isTruthyEnvValue(process.env.POOLBOT_NODE_OPTIONS_READY) ||
+        isTruthyEnvValue(process.env.CLAWDBOT_NODE_OPTIONS_READY))
         return false;
     if (hasExperimentalWarningSuppressed())
         return false;
     // Respawn guard (and keep recursion bounded if something goes wrong).
+    process.env.POOLBOT_NODE_OPTIONS_READY = "1";
     process.env.CLAWDBOT_NODE_OPTIONS_READY = "1";
     // Pass flag as a Node CLI option, not via NODE_OPTIONS (--disable-warning is disallowed in NODE_OPTIONS).
     const child = spawn(process.execPath, [EXPERIMENTAL_WARNING_FLAG, ...process.execArgv, ...process.argv.slice(1)], {

package/dist/gateway/auth.js

@@ -127,8 +127,11 @@ async function resolveVerifiedTailscaleUser(params) {
 export function resolveGatewayAuth(params) {
     const authConfig = params.authConfig ?? {};
     const env = params.env ?? process.env;
-    const token = authConfig.token ?? env.CLAWDBOT_GATEWAY_TOKEN ?? undefined;
-    const password = authConfig.password ?? env.CLAWDBOT_GATEWAY_PASSWORD ?? undefined;
+    const token = authConfig.token ?? env.POOLBOT_GATEWAY_TOKEN ?? env.CLAWDBOT_GATEWAY_TOKEN ?? undefined;
+    const password = authConfig.password ??
+        env.POOLBOT_GATEWAY_PASSWORD ??
+        env.CLAWDBOT_GATEWAY_PASSWORD ??
+        undefined;
     const mode = authConfig.mode ?? (password ? "password" : "token");
     const allowTailscale = authConfig.allowTailscale ?? (params.tailscaleMode === "serve" && mode !== "password");
     return {
@@ -142,7 +145,7 @@ export function assertGatewayAuthConfigured(auth) {
     if (auth.mode === "token" && !auth.token) {
         if (auth.allowTailscale)
             return;
-        throw new Error("gateway auth mode is token, but no token was configured (set gateway.auth.token or CLAWDBOT_GATEWAY_TOKEN)");
+        throw new Error("gateway auth mode is token, but no token was configured (set gateway.auth.token or POOLBOT_GATEWAY_TOKEN)");
     }
     if (auth.mode === "password" && !auth.password) {
         throw new Error("gateway auth mode is password, but no password was configured");

package/dist/gateway/call.js

@@ -95,13 +95,15 @@ export async function callGateway(opts) {
             ? typeof remote?.token === "string" && remote.token.trim().length > 0
                 ? remote.token.trim()
                 : undefined
-            : process.env.CLAWDBOT_GATEWAY_TOKEN?.trim() ||
+            : process.env.POOLBOT_GATEWAY_TOKEN?.trim() ||
+                process.env.CLAWDBOT_GATEWAY_TOKEN?.trim() ||
                 (typeof authToken === "string" && authToken.trim().length > 0
                     ? authToken.trim()
                     : undefined));
     const password = (typeof opts.password === "string" && opts.password.trim().length > 0
         ? opts.password.trim()
         : undefined) ||
+        process.env.POOLBOT_GATEWAY_PASSWORD?.trim() ||
         process.env.CLAWDBOT_GATEWAY_PASSWORD?.trim() ||
         (isRemoteMode
             ? typeof remote?.password === "string" && remote.password.trim().length > 0

package/dist/gateway/server/ws-connection/message-handler.js

@@ -642,7 +642,10 @@ export function attachGatewayWsMessageHandler(params) {
                     type: "hello-ok",
                     protocol: PROTOCOL_VERSION,
                     server: {
-                        version: process.env.CLAWDBOT_VERSION ?? process.env.npm_package_version ?? "dev",
+                        version: process.env.POOLBOT_VERSION ??
+                            process.env.CLAWDBOT_VERSION ??
+                            process.env.npm_package_version ??
+                            "dev",
                         commit: process.env.GIT_COMMIT,
                         host: os.hostname(),
                         connId,

package/dist/gateway/server-browser.js

@@ -1,10 +1,12 @@
 import { isTruthyEnvValue } from "../infra/env.js";
 export async function startBrowserControlServerIfEnabled() {
-    if (isTruthyEnvValue(process.env.CLAWDBOT_SKIP_BROWSER_CONTROL_SERVER))
+    if (isTruthyEnvValue(process.env.POOLBOT_SKIP_BROWSER_CONTROL_SERVER ||
+        process.env.CLAWDBOT_SKIP_BROWSER_CONTROL_SERVER))
         return null;
     // Lazy import: keeps startup fast, but still bundles for the embedded
     // gateway (bun --compile) via the static specifier path.
-    const override = process.env.CLAWDBOT_BROWSER_CONTROL_MODULE?.trim();
+    const override = process.env.POOLBOT_BROWSER_CONTROL_MODULE?.trim() ||
+        process.env.CLAWDBOT_BROWSER_CONTROL_MODULE?.trim();
     const mod = override ? await import(override) : await import("../browser/control-service.js");
     const start = typeof mod
         .startBrowserControlServiceFromConfig === "function"

package/dist/gateway/server-constants.js

@@ -16,8 +16,11 @@ export const __setMaxChatHistoryMessagesBytesForTest = (value) => {
 };
 export const DEFAULT_HANDSHAKE_TIMEOUT_MS = 10_000;
 export const getHandshakeTimeoutMs = () => {
-    if (process.env.VITEST && process.env.CLAWDBOT_TEST_HANDSHAKE_TIMEOUT_MS) {
-        const parsed = Number(process.env.CLAWDBOT_TEST_HANDSHAKE_TIMEOUT_MS);
+    if (process.env.VITEST &&
+        (process.env.POOLBOT_TEST_HANDSHAKE_TIMEOUT_MS ||
+            process.env.CLAWDBOT_TEST_HANDSHAKE_TIMEOUT_MS)) {
+        const parsed = Number(process.env.POOLBOT_TEST_HANDSHAKE_TIMEOUT_MS ||
+            process.env.CLAWDBOT_TEST_HANDSHAKE_TIMEOUT_MS);
         if (Number.isFinite(parsed) && parsed > 0)
             return parsed;
     }

package/dist/gateway/server-cron.js

@@ -14,7 +14,9 @@ import { defaultRuntime } from "../runtime.js";
 export function buildGatewayCronService(params) {
     const cronLogger = getChildLogger({ module: "cron" });
     const storePath = resolveCronStorePath(params.cfg.cron?.store);
-    const cronEnabled = process.env.CLAWDBOT_SKIP_CRON !== "1" && params.cfg.cron?.enabled !== false;
+    const cronEnabled = process.env.POOLBOT_SKIP_CRON !== "1" &&
+        process.env.CLAWDBOT_SKIP_CRON !== "1" &&
+        params.cfg.cron?.enabled !== false;
     const resolveCronAgent = (requested) => {
         const runtimeConfig = loadConfig();
         const normalized = typeof requested === "string" && requested.trim() ? normalizeAgentId(requested) : undefined;

package/dist/gateway/server-discovery-runtime.js

@@ -7,6 +7,7 @@ export async function startGatewayDiscovery(params) {
     const mdnsMode = params.mdnsMode ?? "minimal";
     // mDNS can be disabled via config (mdnsMode: off) or env var.
     const bonjourEnabled = mdnsMode !== "off" &&
+        process.env.POOLBOT_DISABLE_BONJOUR !== "1" &&
         process.env.CLAWDBOT_DISABLE_BONJOUR !== "1" &&
         process.env.NODE_ENV !== "test" &&
         !process.env.VITEST;
@@ -16,7 +17,9 @@ export async function startGatewayDiscovery(params) {
     const tailnetDns = needsTailnetDns
         ? await resolveTailnetDnsHint({ enabled: tailscaleEnabled })
         : undefined;
-    const sshPortEnv = mdnsMinimal ? undefined : process.env.CLAWDBOT_SSH_PORT?.trim();
+    const sshPortEnv = mdnsMinimal
+        ? undefined
+        : process.env.POOLBOT_SSH_PORT?.trim() || process.env.CLAWDBOT_SSH_PORT?.trim();
     const sshPortParsed = sshPortEnv ? Number.parseInt(sshPortEnv, 10) : NaN;
     const sshPort = Number.isFinite(sshPortParsed) && sshPortParsed > 0 ? sshPortParsed : undefined;
     const cliPath = mdnsMinimal ? undefined : resolveBonjourCliPath();

package/dist/gateway/server-discovery.js

@@ -12,7 +12,7 @@ export function formatBonjourInstanceName(displayName) {
 }
 export function resolveBonjourCliPath(opts = {}) {
     const env = opts.env ?? process.env;
-    const envPath = env.CLAWDBOT_CLI_PATH?.trim();
+    const envPath = env.POOLBOT_CLI_PATH?.trim() || env.CLAWDBOT_CLI_PATH?.trim();
     if (envPath)
         return envPath;
     const statSync = opts.statSync ?? fs.statSync;
@@ -45,7 +45,7 @@ export function resolveBonjourCliPath(opts = {}) {
 }
 export async function resolveTailnetDnsHint(opts) {
     const env = opts?.env ?? process.env;
-    const envRaw = env.CLAWDBOT_TAILNET_DNS?.trim();
+    const envRaw = env.POOLBOT_TAILNET_DNS?.trim() || env.CLAWDBOT_TAILNET_DNS?.trim();
     const envValue = envRaw && envRaw.length > 0 ? envRaw.replace(/\.$/, "") : "";
     if (envValue)
         return envValue;

package/dist/gateway/server-reload-handlers.js

@@ -48,7 +48,7 @@ export function createGatewayReloadHandlers(params) {
         }
         if (plan.restartGmailWatcher) {
             await stopGmailWatcher().catch(() => { });
-            if (!isTruthyEnvValue(process.env.CLAWDBOT_SKIP_GMAIL_WATCHER)) {
+            if (!isTruthyEnvValue(process.env.POOLBOT_SKIP_GMAIL_WATCHER || process.env.CLAWDBOT_SKIP_GMAIL_WATCHER)) {
                 try {
                     const gmailResult = await startGmailWatcher(nextConfig);
                     if (gmailResult.started) {
@@ -65,13 +65,13 @@ export function createGatewayReloadHandlers(params) {
                 }
             }
             else {
-                params.logHooks.info("skipping gmail watcher restart (CLAWDBOT_SKIP_GMAIL_WATCHER=1)");
+                params.logHooks.info("skipping gmail watcher restart (POOLBOT_SKIP_GMAIL_WATCHER=1)");
             }
         }
         if (plan.restartChannels.size > 0) {
-            if (isTruthyEnvValue(process.env.CLAWDBOT_SKIP_CHANNELS) ||
+            if (isTruthyEnvValue(process.env.POOLBOT_SKIP_CHANNELS || process.env.CLAWDBOT_SKIP_CHANNELS) ||
                 isTruthyEnvValue(process.env.CLAWDBOT_SKIP_PROVIDERS)) {
-                params.logChannels.info("skipping channel reload (CLAWDBOT_SKIP_CHANNELS=1 or CLAWDBOT_SKIP_PROVIDERS=1)");
+                params.logChannels.info("skipping channel reload (POOLBOT_SKIP_CHANNELS=1 / CLAWDBOT_SKIP_CHANNELS=1 or CLAWDBOT_SKIP_PROVIDERS=1)");
             }
             else {
                 const restartChannel = async (name) => {

package/dist/gateway/server-runtime-config.js

@@ -39,13 +39,13 @@ export async function resolveGatewayRuntimeConfig(params) {
     const canvasHostEnabled = process.env.CLAWDBOT_SKIP_CANVAS_HOST !== "1" && params.cfg.canvasHost?.enabled !== false;
     assertGatewayAuthConfigured(resolvedAuth);
     if (tailscaleMode === "funnel" && authMode !== "password") {
-        throw new Error("tailscale funnel requires gateway auth mode=password (set gateway.auth.password or CLAWDBOT_GATEWAY_PASSWORD)");
+        throw new Error("tailscale funnel requires gateway auth mode=password (set gateway.auth.password or POOLBOT_GATEWAY_PASSWORD)");
     }
     if (tailscaleMode !== "off" && !isLoopbackHost(bindHost)) {
         throw new Error("tailscale serve/funnel requires gateway bind=loopback (127.0.0.1)");
     }
     if (!isLoopbackHost(bindHost) && !hasSharedSecret) {
-        throw new Error(`refusing to bind gateway to ${bindHost}:${params.port} without auth (set gateway.auth.token/password, or set CLAWDBOT_GATEWAY_TOKEN/CLAWDBOT_GATEWAY_PASSWORD)`);
+        throw new Error(`refusing to bind gateway to ${bindHost}:${params.port} without auth (set gateway.auth.token/password, or set POOLBOT_GATEWAY_TOKEN/POOLBOT_GATEWAY_PASSWORD)`);
     }
     return {
         bindHost,

package/dist/gateway/server-startup.js

@@ -18,7 +18,7 @@ export async function startGatewaySidecars(params) {
         params.logBrowser.error(`server failed to start: ${String(err)}`);
     }
     // Start Gmail watcher if configured (hooks.gmail.account).
-    if (!isTruthyEnvValue(process.env.CLAWDBOT_SKIP_GMAIL_WATCHER)) {
+    if (!isTruthyEnvValue(process.env.POOLBOT_SKIP_GMAIL_WATCHER || process.env.CLAWDBOT_SKIP_GMAIL_WATCHER)) {
         try {
             const gmailResult = await startGmailWatcher(params.cfg);
             if (gmailResult.started) {
@@ -75,8 +75,8 @@ export async function startGatewaySidecars(params) {
         params.logHooks.error(`failed to load hooks: ${String(err)}`);
     }
     // Launch configured channels so gateway replies via the surface the message came from.
-    // Tests can opt out via CLAWDBOT_SKIP_CHANNELS (or legacy CLAWDBOT_SKIP_PROVIDERS).
-    const skipChannels = isTruthyEnvValue(process.env.CLAWDBOT_SKIP_CHANNELS) ||
+    // Tests can opt out via POOLBOT_SKIP_CHANNELS / CLAWDBOT_SKIP_CHANNELS (or legacy CLAWDBOT_SKIP_PROVIDERS).
+    const skipChannels = isTruthyEnvValue(process.env.POOLBOT_SKIP_CHANNELS || process.env.CLAWDBOT_SKIP_CHANNELS) ||
         isTruthyEnvValue(process.env.CLAWDBOT_SKIP_PROVIDERS);
     if (!skipChannels) {
         try {
@@ -87,7 +87,7 @@ export async function startGatewaySidecars(params) {
         }
     }
     else {
-        params.logChannels.info("skipping channel start (CLAWDBOT_SKIP_CHANNELS=1 or CLAWDBOT_SKIP_PROVIDERS=1)");
+        params.logChannels.info("skipping channel start (POOLBOT_SKIP_CHANNELS=1 / CLAWDBOT_SKIP_CHANNELS=1 or CLAWDBOT_SKIP_PROVIDERS=1)");
     }
     if (params.cfg.hooks?.internal?.enabled) {
         setTimeout(() => {

package/dist/gateway/server.impl.js

@@ -66,13 +66,14 @@ const logWsControl = log.child("ws");
 const canvasRuntime = runtimeForLogger(logCanvas);
 export async function startGatewayServer(port = 18789, opts = {}) {
     // Ensure all default port derivations (browser/canvas) see the actual runtime port.
+    process.env.POOLBOT_GATEWAY_PORT = String(port);
     process.env.CLAWDBOT_GATEWAY_PORT = String(port);
     logAcceptedEnvOption({
-        key: "CLAWDBOT_RAW_STREAM",
+        key: "POOLBOT_RAW_STREAM",
         description: "raw stream logging enabled",
     });
     logAcceptedEnvOption({
-        key: "CLAWDBOT_RAW_STREAM_PATH",
+        key: "POOLBOT_RAW_STREAM_PATH",
         description: "raw stream log path override",
     });
     let configSnapshot = await readConfigFileSnapshot();

package/dist/gateway/test-helpers.mocks.js

@@ -167,6 +167,7 @@ const testConfigRoot = {
 };
 export const setTestConfigRoot = (root) => {
     testConfigRoot.value = root;
+    process.env.POOLBOT_CONFIG_PATH = path.join(root, "poolbot.json");
     process.env.CLAWDBOT_CONFIG_PATH = path.join(root, "poolbot.json");
 };
 export const testTailnetIPv4 = hoisted.testTailnetIPv4;
@@ -502,5 +503,7 @@ vi.mock("../cli/deps.js", async () => {
         }),
     };
 });
+process.env.POOLBOT_SKIP_CHANNELS = "1";
 process.env.CLAWDBOT_SKIP_CHANNELS = "1";
+process.env.POOLBOT_SKIP_CRON = "1";
 process.env.CLAWDBOT_SKIP_CRON = "1";

package/dist/gateway/test-helpers.server.js

@@ -52,25 +52,37 @@ export async function writeSessionStore(params) {
 async function setupGatewayTestHome() {
     previousHome = process.env.HOME;
     previousUserProfile = process.env.USERPROFILE;
-    previousStateDir = process.env.CLAWDBOT_STATE_DIR;
-    previousConfigPath = process.env.CLAWDBOT_CONFIG_PATH;
-    previousSkipBrowserControl = process.env.CLAWDBOT_SKIP_BROWSER_CONTROL_SERVER;
-    previousSkipGmailWatcher = process.env.CLAWDBOT_SKIP_GMAIL_WATCHER;
-    previousSkipCanvasHost = process.env.CLAWDBOT_SKIP_CANVAS_HOST;
-    previousBundledPluginsDir = process.env.CLAWDBOT_BUNDLED_PLUGINS_DIR;
+    previousStateDir = process.env.POOLBOT_STATE_DIR ?? process.env.CLAWDBOT_STATE_DIR;
+    previousConfigPath = process.env.POOLBOT_CONFIG_PATH ?? process.env.CLAWDBOT_CONFIG_PATH;
+    previousSkipBrowserControl =
+        process.env.POOLBOT_SKIP_BROWSER_CONTROL_SERVER ??
+            process.env.CLAWDBOT_SKIP_BROWSER_CONTROL_SERVER;
+    previousSkipGmailWatcher =
+        process.env.POOLBOT_SKIP_GMAIL_WATCHER ?? process.env.CLAWDBOT_SKIP_GMAIL_WATCHER;
+    previousSkipCanvasHost =
+        process.env.POOLBOT_SKIP_CANVAS_HOST ?? process.env.CLAWDBOT_SKIP_CANVAS_HOST;
+    previousBundledPluginsDir =
+        process.env.POOLBOT_BUNDLED_PLUGINS_DIR ?? process.env.CLAWDBOT_BUNDLED_PLUGINS_DIR;
     tempHome = await fs.mkdtemp(path.join(os.tmpdir(), "poolbot-gateway-home-"));
     process.env.HOME = tempHome;
     process.env.USERPROFILE = tempHome;
+    process.env.POOLBOT_STATE_DIR = path.join(tempHome, ".poolbot");
     process.env.CLAWDBOT_STATE_DIR = path.join(tempHome, ".poolbot");
+    delete process.env.POOLBOT_CONFIG_PATH;
     delete process.env.CLAWDBOT_CONFIG_PATH;
 }
 function applyGatewaySkipEnv() {
+    process.env.POOLBOT_SKIP_BROWSER_CONTROL_SERVER = "1";
     process.env.CLAWDBOT_SKIP_BROWSER_CONTROL_SERVER = "1";
+    process.env.POOLBOT_SKIP_GMAIL_WATCHER = "1";
     process.env.CLAWDBOT_SKIP_GMAIL_WATCHER = "1";
+    process.env.POOLBOT_SKIP_CANVAS_HOST = "1";
     process.env.CLAWDBOT_SKIP_CANVAS_HOST = "1";
-    process.env.CLAWDBOT_BUNDLED_PLUGINS_DIR = tempHome
+    const bundledDir = tempHome
         ? path.join(tempHome, "poolbot-test-no-bundled-extensions")
         : "poolbot-test-no-bundled-extensions";
+    process.env.POOLBOT_BUNDLED_PLUGINS_DIR = bundledDir;
+    process.env.CLAWDBOT_BUNDLED_PLUGINS_DIR = bundledDir;
 }
 async function resetGatewayTestState(options) {
     // Some tests intentionally use fake timers; ensure they don't leak into gateway suites.
@@ -131,30 +143,54 @@ async function cleanupGatewayTestHome(options) {
             delete process.env.USERPROFILE;
         else
             process.env.USERPROFILE = previousUserProfile;
-        if (previousStateDir === undefined)
+        if (previousStateDir === undefined) {
+            delete process.env.POOLBOT_STATE_DIR;
             delete process.env.CLAWDBOT_STATE_DIR;
-        else
+        }
+        else {
+            process.env.POOLBOT_STATE_DIR = previousStateDir;
             process.env.CLAWDBOT_STATE_DIR = previousStateDir;
-        if (previousConfigPath === undefined)
+        }
+        if (previousConfigPath === undefined) {
+            delete process.env.POOLBOT_CONFIG_PATH;
             delete process.env.CLAWDBOT_CONFIG_PATH;
-        else
+        }
+        else {
+            process.env.POOLBOT_CONFIG_PATH = previousConfigPath;
             process.env.CLAWDBOT_CONFIG_PATH = previousConfigPath;
-        if (previousSkipBrowserControl === undefined)
+        }
+        if (previousSkipBrowserControl === undefined) {
+            delete process.env.POOLBOT_SKIP_BROWSER_CONTROL_SERVER;
             delete process.env.CLAWDBOT_SKIP_BROWSER_CONTROL_SERVER;
-        else
+        }
+        else {
+            process.env.POOLBOT_SKIP_BROWSER_CONTROL_SERVER = previousSkipBrowserControl;
             process.env.CLAWDBOT_SKIP_BROWSER_CONTROL_SERVER = previousSkipBrowserControl;
-        if (previousSkipGmailWatcher === undefined)
+        }
+        if (previousSkipGmailWatcher === undefined) {
+            delete process.env.POOLBOT_SKIP_GMAIL_WATCHER;
             delete process.env.CLAWDBOT_SKIP_GMAIL_WATCHER;
-        else
+        }
+        else {
+            process.env.POOLBOT_SKIP_GMAIL_WATCHER = previousSkipGmailWatcher;
             process.env.CLAWDBOT_SKIP_GMAIL_WATCHER = previousSkipGmailWatcher;
-        if (previousSkipCanvasHost === undefined)
+        }
+        if (previousSkipCanvasHost === undefined) {
+            delete process.env.POOLBOT_SKIP_CANVAS_HOST;
             delete process.env.CLAWDBOT_SKIP_CANVAS_HOST;
-        else
+        }
+        else {
+            process.env.POOLBOT_SKIP_CANVAS_HOST = previousSkipCanvasHost;
             process.env.CLAWDBOT_SKIP_CANVAS_HOST = previousSkipCanvasHost;
-        if (previousBundledPluginsDir === undefined)
+        }
+        if (previousBundledPluginsDir === undefined) {
+            delete process.env.POOLBOT_BUNDLED_PLUGINS_DIR;
             delete process.env.CLAWDBOT_BUNDLED_PLUGINS_DIR;
-        else
+        }
+        else {
+            process.env.POOLBOT_BUNDLED_PLUGINS_DIR = previousBundledPluginsDir;
             process.env.CLAWDBOT_BUNDLED_PLUGINS_DIR = previousBundledPluginsDir;
+        }
     }
     if (options.restoreEnv && tempHome) {
         await fs.rm(tempHome, {
@@ -238,7 +274,7 @@ export async function startGatewayServer(port, opts) {
 }
 export async function startServerWithClient(token, opts) {
     let port = await getFreePort();
-    const prev = process.env.CLAWDBOT_GATEWAY_TOKEN;
+    const prev = process.env.POOLBOT_GATEWAY_TOKEN ?? process.env.CLAWDBOT_GATEWAY_TOKEN;
     if (typeof token === "string") {
         testState.gatewayAuth = { mode: "token", token };
     }
@@ -247,9 +283,11 @@ export async function startServerWithClient(token, opts) {
             ? testState.gatewayAuth.token
             : undefined);
     if (fallbackToken === undefined) {
+        delete process.env.POOLBOT_GATEWAY_TOKEN;
         delete process.env.CLAWDBOT_GATEWAY_TOKEN;
     }
     else {
+        process.env.POOLBOT_GATEWAY_TOKEN = fallbackToken;
         process.env.CLAWDBOT_GATEWAY_TOKEN = fallbackToken;
     }
     let server = null;
@@ -309,12 +347,12 @@ export async function connectReq(ws, opts) {
         ? undefined
         : typeof testState.gatewayAuth?.token === "string"
             ? (testState.gatewayAuth.token ?? undefined)
-            : process.env.CLAWDBOT_GATEWAY_TOKEN;
+            : (process.env.POOLBOT_GATEWAY_TOKEN ?? process.env.CLAWDBOT_GATEWAY_TOKEN);
     const defaultPassword = opts?.skipDefaultAuth === true
         ? undefined
         : typeof testState.gatewayAuth?.password === "string"
             ? (testState.gatewayAuth.password ?? undefined)
-            : process.env.CLAWDBOT_GATEWAY_PASSWORD;
+            : (process.env.POOLBOT_GATEWAY_PASSWORD ?? process.env.CLAWDBOT_GATEWAY_PASSWORD);
     const token = opts?.token ?? defaultToken;
     const password = opts?.password ?? defaultPassword;
     const requestedScopes = Array.isArray(opts?.scopes) ? opts?.scopes : [];

package/dist/hooks/bundled-dir.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 export function resolveBundledHooksDir() {
-    const override = process.env.CLAWDBOT_BUNDLED_HOOKS_DIR?.trim();
+    const override = process.env.POOLBOT_BUNDLED_HOOKS_DIR?.trim() || process.env.CLAWDBOT_BUNDLED_HOOKS_DIR?.trim();
     if (override)
         return override;
     // bun --compile: ship a sibling `hooks/bundled/` next to the executable.

package/dist/hooks/gmail-watcher.js

@@ -78,7 +78,7 @@ function spawnGogServe(cfg) {
             return;
         if (addressInUse) {
             log.warn("gog serve failed to bind (address already in use); stopping restarts. " +
-                "Another watcher is likely running. Set CLAWDBOT_SKIP_GMAIL_WATCHER=1 or stop the other process.");
+                "Another watcher is likely running. Set POOLBOT_SKIP_GMAIL_WATCHER=1 or stop the other process.");
             watcherProcess = null;
             return;
         }

package/dist/infra/bonjour.js

@@ -6,7 +6,7 @@ import { formatBonjourError } from "./bonjour-errors.js";
 import { isTruthyEnvValue } from "./env.js";
 import { registerUnhandledRejectionHandler } from "./unhandled-rejections.js";
 function isDisabledByEnv() {
-    if (isTruthyEnvValue(process.env.CLAWDBOT_DISABLE_BONJOUR))
+    if (isTruthyEnvValue(process.env.POOLBOT_DISABLE_BONJOUR ?? process.env.CLAWDBOT_DISABLE_BONJOUR))
         return true;
     if (process.env.NODE_ENV === "test")
         return true;

package/dist/infra/diagnostic-flags.js

@@ -1,4 +1,5 @@
-const DIAGNOSTICS_ENV = "CLAWDBOT_DIAGNOSTICS";
+const DIAGNOSTICS_ENV = "POOLBOT_DIAGNOSTICS";
+const DIAGNOSTICS_ENV_LEGACY = "CLAWDBOT_DIAGNOSTICS";
 function normalizeFlag(value) {
     return value.trim().toLowerCase();
 }
@@ -32,7 +33,7 @@ function uniqueFlags(flags) {
 }
 export function resolveDiagnosticFlags(cfg, env = process.env) {
     const configFlags = Array.isArray(cfg?.diagnostics?.flags) ? cfg?.diagnostics?.flags : [];
-    const envFlags = parseEnvFlags(env[DIAGNOSTICS_ENV]);
+    const envFlags = parseEnvFlags(env[DIAGNOSTICS_ENV] ?? env[DIAGNOSTICS_ENV_LEGACY]);
     return uniqueFlags([...configFlags, ...envFlags]);
 }
 export function matchesDiagnosticFlag(flag, enabledFlags) {

package/dist/infra/dotenv.js

@@ -6,7 +6,7 @@ export function loadDotEnv(opts) {
     const quiet = opts?.quiet ?? true;
     // Load from process CWD first (dotenv default).
     dotenv.config({ quiet });
-    // Then load global fallback: ~/.poolbot/.env (or CLAWDBOT_STATE_DIR/.env),
+    // Then load global fallback: ~/.poolbot/.env (or POOLBOT_STATE_DIR/.env),
     // without overriding any env vars already present.
     const globalEnvPath = path.join(resolveConfigDir(process.env), ".env");
     if (!fs.existsSync(globalEnvPath))

package/dist/infra/gateway-lock.js

@@ -126,7 +126,7 @@ function resolveGatewayLockPath(env) {
 export async function acquireGatewayLock(opts = {}) {
     const env = opts.env ?? process.env;
     const allowInTests = opts.allowInTests === true;
-    if (env.CLAWDBOT_ALLOW_MULTI_GATEWAY === "1" ||
+    if ((env.POOLBOT_ALLOW_MULTI_GATEWAY ?? env.CLAWDBOT_ALLOW_MULTI_GATEWAY) === "1" ||
         (!allowInTests && (env.VITEST || env.NODE_ENV === "test"))) {
         return null;
     }

package/dist/infra/home-dir.js

@@ -9,7 +9,7 @@ export function resolveEffectiveHomeDir(env = process.env, homedir = os.homedir)
     return raw ? path.resolve(raw) : undefined;
 }
 function resolveRawHomeDir(env, homedir) {
-    const explicitHome = normalize(env.CLAWDBOT_HOME);
+    const explicitHome = normalize(env.POOLBOT_HOME) ?? normalize(env.CLAWDBOT_HOME);
     if (explicitHome) {
         if (explicitHome === "~" || explicitHome.startsWith("~/") || explicitHome.startsWith("~\\")) {
             const fallbackHome = normalize(env.HOME) ?? normalize(env.USERPROFILE) ?? normalizeSafe(homedir);

package/dist/infra/path-env.js

@@ -80,8 +80,9 @@ function candidateBinDirs(opts) {
  * under launchd/minimal environments (and inside the macOS app bundle).
  */
 export function ensurePoolbotCliOnPath(opts = {}) {
-    if (isTruthyEnvValue(process.env.CLAWDBOT_PATH_BOOTSTRAPPED))
+    if (isTruthyEnvValue(process.env.POOLBOT_PATH_BOOTSTRAPPED ?? process.env.CLAWDBOT_PATH_BOOTSTRAPPED))
         return;
+    process.env.POOLBOT_PATH_BOOTSTRAPPED = "1";
     process.env.CLAWDBOT_PATH_BOOTSTRAPPED = "1";
     const existing = opts.pathEnv ?? process.env.PATH ?? "";
     const prepend = candidateBinDirs(opts);

package/dist/infra/restart.js

@@ -78,7 +78,7 @@ export function triggerPoolbotRestart() {
     const tried = [];
     if (process.platform !== "darwin") {
         if (process.platform === "linux") {
-            const unit = normalizeSystemdUnit(process.env.CLAWDBOT_SYSTEMD_UNIT, process.env.CLAWDBOT_PROFILE);
+            const unit = normalizeSystemdUnit(process.env.POOLBOT_SYSTEMD_UNIT ?? process.env.CLAWDBOT_SYSTEMD_UNIT, process.env.POOLBOT_PROFILE ?? process.env.CLAWDBOT_PROFILE);
             const userArgs = ["--user", "restart", unit];
             tried.push(`systemctl ${userArgs.join(" ")}`);
             const userRestart = spawnSync("systemctl", userArgs, {
@@ -109,8 +109,9 @@ export function triggerPoolbotRestart() {
             detail: "unsupported platform restart",
         };
     }
-    const label = process.env.CLAWDBOT_LAUNCHD_LABEL ||
-        resolveGatewayLaunchAgentLabel(process.env.CLAWDBOT_PROFILE);
+    const label = process.env.POOLBOT_LAUNCHD_LABEL ||
+        process.env.CLAWDBOT_LAUNCHD_LABEL ||
+        resolveGatewayLaunchAgentLabel(process.env.POOLBOT_PROFILE ?? process.env.CLAWDBOT_PROFILE);
     const uid = typeof process.getuid === "function" ? process.getuid() : undefined;
     const target = uid !== undefined ? `gui/${uid}/${label}` : label;
     const args = ["kickstart", "-k", target];

package/dist/infra/shell-env.js

@@ -72,13 +72,14 @@ export function loadShellEnvFallback(opts) {
     return { ok: true, applied };
 }
 export function shouldEnableShellEnvFallback(env) {
-    return isTruthyEnvValue(env.CLAWDBOT_LOAD_SHELL_ENV);
+    return (isTruthyEnvValue(env.POOLBOT_LOAD_SHELL_ENV) || isTruthyEnvValue(env.CLAWDBOT_LOAD_SHELL_ENV));
 }
 export function shouldDeferShellEnvFallback(env) {
-    return isTruthyEnvValue(env.CLAWDBOT_DEFER_SHELL_ENV_FALLBACK);
+    return (isTruthyEnvValue(env.POOLBOT_DEFER_SHELL_ENV_FALLBACK) ||
+        isTruthyEnvValue(env.CLAWDBOT_DEFER_SHELL_ENV_FALLBACK));
 }
 export function resolveShellEnvFallbackTimeoutMs(env) {
-    const raw = env.CLAWDBOT_SHELL_ENV_TIMEOUT_MS?.trim();
+    const raw = env.POOLBOT_SHELL_ENV_TIMEOUT_MS?.trim() || env.CLAWDBOT_SHELL_ENV_TIMEOUT_MS?.trim();
     if (!raw)
         return DEFAULT_TIMEOUT_MS;
     const parsed = Number.parseInt(raw, 10);

package/dist/infra/state-migrations.js

@@ -324,7 +324,7 @@ export async function autoMigrateLegacyStateDir(params) {
     }
     autoMigrateStateDirChecked = true;
     const env = params.env ?? process.env;
-    if (env.CLAWDBOT_STATE_DIR?.trim()) {
+    if (env.POOLBOT_STATE_DIR?.trim() || env.CLAWDBOT_STATE_DIR?.trim()) {
         return { migrated: false, skipped: true, changes: [], warnings: [] };
     }
     const homedir = params.homedir ?? os.homedir;
@@ -439,7 +439,7 @@ export async function autoMigrateLegacyStateDir(params) {
             }
             catch (rollbackErr) {
                 warnings.push(`State dir moved but failed to link legacy path (${legacyDir ?? "unknown"} → ${targetDir}): ${String(fallbackErr)}`);
-                warnings.push(`Rollback failed; set CLAWDBOT_STATE_DIR=${targetDir} to avoid split state: ${String(rollbackErr)}`);
+                warnings.push(`Rollback failed; set POOLBOT_STATE_DIR=${targetDir} to avoid split state: ${String(rollbackErr)}`);
                 changes.push(`State dir: ${legacyDir ?? "unknown"} → ${targetDir}`);
             }
         }
@@ -726,7 +726,9 @@ export async function autoMigrateLegacyState(params) {
         homedir: params.homedir,
         log: params.log,
     });
-    if (env.CLAWDBOT_AGENT_DIR?.trim() || env.PI_CODING_AGENT_DIR?.trim()) {
+    if (env.POOLBOT_AGENT_DIR?.trim() ||
+        env.CLAWDBOT_AGENT_DIR?.trim() ||
+        env.PI_CODING_AGENT_DIR?.trim()) {
         return {
             migrated: stateDirResult.migrated,
             skipped: true,

package/dist/infra/system-presence.js

@@ -33,7 +33,10 @@ function resolvePrimaryIPv4() {
 function initSelfPresence() {
     const host = os.hostname();
     const ip = resolvePrimaryIPv4() ?? undefined;
-    const version = process.env.CLAWDBOT_VERSION ?? process.env.npm_package_version ?? "unknown";
+    const version = process.env.POOLBOT_VERSION ??
+        process.env.CLAWDBOT_VERSION ??
+        process.env.npm_package_version ??
+        "unknown";
     const modelIdentifier = (() => {
         const p = os.platform();
         if (p === "darwin") {

package/dist/infra/update-runner.js

@@ -560,7 +560,10 @@ export async function runGatewayUpdate(opts = {}) {
             };
         }
         const doctorArgv = [process.execPath, doctorEntry, "doctor", "--non-interactive"];
-        const doctorStep = await runStep(step("poolbot doctor", doctorArgv, gitRoot, { CLAWDBOT_UPDATE_IN_PROGRESS: "1" }));
+        const doctorStep = await runStep(step("poolbot doctor", doctorArgv, gitRoot, {
+            POOLBOT_UPDATE_IN_PROGRESS: "1",
+            CLAWDBOT_UPDATE_IN_PROGRESS: "1",
+        }));
         steps.push(doctorStep);
         const uiIndexHealth = await resolveControlUiDistIndexHealth({ root: gitRoot });
         if (!uiIndexHealth.exists) {

package/dist/infra/widearea-dns.js

@@ -11,7 +11,7 @@ export function normalizeWideAreaDomain(raw) {
 }
 export function resolveWideAreaDiscoveryDomain(params) {
     const env = params?.env ?? process.env;
-    const candidate = params?.configDomain ?? env.CLAWDBOT_WIDE_AREA_DOMAIN ?? null;
+    const candidate = params?.configDomain ?? env.POOLBOT_WIDE_AREA_DOMAIN ?? env.CLAWDBOT_WIDE_AREA_DOMAIN ?? null;
     return normalizeWideAreaDomain(candidate);
 }
 function zoneFilenameForDomain(domain) {