@poolzin/pool-bot 2026.1.26 → 2026.1.29

package/dist/infra/{clawdbot-root.js → poolbot-root.js}

@@ -1,6 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+const CORE_PACKAGE_NAMES = new Set(["poolbot", "poolbot"]);
 async function readPackageName(dir) {
     try {
         const raw = await fs.readFile(path.join(dir, "package.json"), "utf-8");
@@ -15,7 +16,7 @@ async function findPackageRoot(startDir, maxDepth = 12) {
     let current = path.resolve(startDir);
     for (let i = 0; i < maxDepth; i += 1) {
         const name = await readPackageName(current);
-        if (name === "clawdbot")
+        if (name && CORE_PACKAGE_NAMES.has(name))
             return current;
         const parent = path.dirname(current);
         if (parent === current)
@@ -36,7 +37,7 @@ function candidateDirsFromArgv1(argv1) {
     }
     return candidates;
 }
-export async function resolveClawdbotPackageRoot(opts) {
+export async function resolvePoolBotPackageRoot(opts) {
     const candidates = [];
     if (opts.moduleUrl) {
         candidates.push(path.dirname(fileURLToPath(opts.moduleUrl)));

package/dist/infra/ports-format.js

@@ -1,7 +1,7 @@
 import { formatCliCommand } from "../cli/command-format.js";
 export function classifyPortListener(listener, port) {
     const raw = `${listener.commandLine ?? ""} ${listener.command ?? ""}`.trim().toLowerCase();
-    if (raw.includes("clawdbot"))
+    if (raw.includes("poolbot"))
         return "gateway";
     if (raw.includes("ssh")) {
         const portToken = String(port);
@@ -18,7 +18,7 @@ export function buildPortHints(listeners, port) {
     const kinds = new Set(listeners.map((listener) => classifyPortListener(listener, port)));
     const hints = [];
     if (kinds.has("gateway")) {
-        hints.push(`Gateway already running locally. Stop it (${formatCliCommand("clawdbot gateway stop")}) or use a different port.`);
+        hints.push(`Gateway already running locally. Stop it (${formatCliCommand("poolbot gateway stop")}) or use a different port.`);
     }
     if (kinds.has("ssh")) {
         hints.push("SSH tunnel already bound to this port. Close the tunnel or use a different local port in -L.");

package/dist/infra/ports.js

@@ -52,8 +52,8 @@ export async function handlePortError(err, port, context, runtime = defaultRunti
         if (details) {
             runtime.error(info("Port listener details:"));
             runtime.error(details);
-            if (/clawdbot|src\/index\.ts|dist\/index\.js/.test(details)) {
-                runtime.error(warn("It looks like another clawdbot instance is already running. Stop it or pick a different port."));
+            if (/poolbot|src\/index\.ts|dist\/index\.js/.test(details)) {
+                runtime.error(warn("It looks like another poolbot instance is already running. Stop it or pick a different port."));
             }
         }
         runtime.error(info("Resolve by stopping the process using the port or passing --port <free-port>."));

package/dist/infra/provider-usage.auth.js

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { CLAUDE_CLI_PROFILE_ID, ensureAuthProfileStore, listProfilesForProvider, resolveApiKeyForProfile, resolveAuthProfileOrder, } from "../agents/auth-profiles.js";
+import { ensureAuthProfileStore, listProfilesForProvider, resolveApiKeyForProfile, resolveAuthProfileOrder, } from "../agents/auth-profiles.js";
 import { getCustomProviderApiKey, resolveEnvApiKey } from "../agents/model-auth.js";
 import { normalizeProviderId } from "../agents/model-selection.js";
 import { loadConfig } from "../config/config.js";
@@ -89,9 +89,7 @@ async function resolveOAuthToken(params) {
         store,
         provider: params.provider,
     });
-    // Claude Code CLI creds are the only Anthropic tokens that reliably include the
-    // `user:profile` scope required for the OAuth usage endpoint.
-    const candidates = params.provider === "anthropic" ? [CLAUDE_CLI_PROFILE_ID, ...order] : order;
+    const candidates = order;
     const deduped = [];
     for (const entry of candidates) {
         if (!deduped.includes(entry))

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

@@ -62,7 +62,7 @@ export async function fetchClaudeUsage(token, timeoutMs, fetchFn) {
     const res = await fetchJson("https://api.anthropic.com/api/oauth/usage", {
         headers: {
             Authorization: `Bearer ${token}`,
-            "User-Agent": "clawdbot",
+            "User-Agent": "poolbot",
             Accept: "application/json",
             "anthropic-version": "2023-06-01",
             "anthropic-beta": "oauth-2025-04-20",

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": "Clawdbot",
+            "MM-API-Source": "Moltbot",
         },
     }, timeoutMs, fetchFn);
     if (!res.ok) {

package/dist/infra/restart-sentinel.js

@@ -4,7 +4,7 @@ import { formatCliCommand } from "../cli/command-format.js";
 import { resolveStateDir } from "../config/paths.js";
 const SENTINEL_FILENAME = "restart-sentinel.json";
 export function formatDoctorNonInteractiveHint(env = process.env) {
-    return `Run: ${formatCliCommand("clawdbot doctor --non-interactive", env)}`;
+    return `Run: ${formatCliCommand("poolbot doctor --non-interactive", env)}`;
 }
 export function resolveRestartSentinelPath(env = process.env) {
     return path.join(resolveStateDir(env), SENTINEL_FILENAME);

package/dist/infra/restart.js

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

package/dist/infra/retry-policy.js

@@ -53,10 +53,13 @@ export function createTelegramRetryRunner(params) {
         ...params.configRetry,
         ...params.retry,
     });
+    const shouldRetry = params.shouldRetry
+        ? (err) => params.shouldRetry?.(err) || TELEGRAM_RETRY_RE.test(formatErrorMessage(err))
+        : (err) => TELEGRAM_RETRY_RE.test(formatErrorMessage(err));
     return (fn, label) => retryAsync(fn, {
         ...retryConfig,
         label,
-        shouldRetry: (err) => TELEGRAM_RETRY_RE.test(formatErrorMessage(err)),
+        shouldRetry,
         retryAfterMs: getTelegramRetryAfterMs,
         onRetry: params.verbose
             ? (info) => {

package/dist/infra/runtime-guard.js

@@ -50,11 +50,11 @@ export function assertSupportedRuntime(runtime = defaultRuntime, details = detec
     const runtimeLabel = details.kind === "unknown" ? "unknown runtime" : `${details.kind} ${versionLabel}`;
     const execLabel = details.execPath ?? "unknown";
     runtime.error([
-        "clawdbot requires Node >=22.0.0.",
+        "poolbot requires Node >=22.0.0.",
         `Detected: ${runtimeLabel} (exec: ${execLabel}).`,
         `PATH searched: ${details.pathEnv}`,
         "Install Node: https://nodejs.org/en/download",
-        "Upgrade Node and re-run clawdbot.",
+        "Upgrade Node and re-run poolbot.",
     ].join("\n"));
     runtime.exit(1);
 }

package/dist/infra/shell-env.js

@@ -53,7 +53,7 @@ export function loadShellEnvFallback(opts) {
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        logger.warn(`[clawdbot] shell env fallback failed: ${msg}`);
+        logger.warn(`[poolbot] shell env fallback failed: ${msg}`);
         lastAppliedKeys = [];
         return { ok: false, error: msg, applied: [] };
     }

package/dist/infra/skills-remote.js

@@ -139,11 +139,11 @@ function listWorkspaceDirs(cfg) {
 function collectRequiredBins(entries, targetPlatform) {
     const bins = new Set();
     for (const entry of entries) {
-        const os = entry.clawdbot?.os ?? [];
+        const os = entry.metadata?.os ?? [];
         if (os.length > 0 && !os.includes(targetPlatform))
             continue;
-        const required = entry.clawdbot?.requires?.bins ?? [];
-        const anyBins = entry.clawdbot?.requires?.anyBins ?? [];
+        const required = entry.metadata?.requires?.bins ?? [];
+        const anyBins = entry.metadata?.requires?.anyBins ?? [];
         for (const bin of required) {
             if (bin.trim())
                 bins.add(bin.trim());

package/dist/infra/tailscale.js

@@ -173,6 +173,7 @@ export async function ensureTailscaledInstalled(exec = runExec, prompt = promptY
     logVerbose("Installing tailscaled via Homebrew…");
     await exec("brew", ["install", "tailscale"]);
 }
+const whoisCache = new Map();
 function extractExecErrorText(err) {
     const errOutput = err;
     const stdout = typeof errOutput.stdout === "string" ? errOutput.stdout : "";
@@ -262,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 CLAWDBOT. You can keep running the web gateway without it: \`${formatCliCommand("clawdbot gateway")}\``));
+        runtime.error(info(`Tip: Funnel is optional for Moltbot. You can keep running the web gateway without it: \`${formatCliCommand("poolbot gateway")}\``));
         if (shouldLogVerbose()) {
             const rich = isRich();
             if (stdout.trim()) {
@@ -304,3 +305,64 @@ export async function disableTailscaleFunnel(exec = runExec) {
         timeoutMs: 15_000,
     });
 }
+function getString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function readRecord(value) {
+    return value && typeof value === "object" ? value : null;
+}
+function parseWhoisIdentity(payload) {
+    const userProfile = readRecord(payload.UserProfile) ?? readRecord(payload.userProfile) ?? readRecord(payload.User);
+    const login = getString(userProfile?.LoginName) ??
+        getString(userProfile?.Login) ??
+        getString(userProfile?.login) ??
+        getString(payload.LoginName) ??
+        getString(payload.login);
+    if (!login)
+        return null;
+    const name = getString(userProfile?.DisplayName) ??
+        getString(userProfile?.Name) ??
+        getString(userProfile?.displayName) ??
+        getString(payload.DisplayName) ??
+        getString(payload.name);
+    return { login, name };
+}
+function readCachedWhois(ip, now) {
+    const cached = whoisCache.get(ip);
+    if (!cached)
+        return undefined;
+    if (cached.expiresAt <= now) {
+        whoisCache.delete(ip);
+        return undefined;
+    }
+    return cached.value;
+}
+function writeCachedWhois(ip, value, ttlMs) {
+    whoisCache.set(ip, { value, expiresAt: Date.now() + ttlMs });
+}
+export async function readTailscaleWhoisIdentity(ip, exec = runExec, opts) {
+    const normalized = ip.trim();
+    if (!normalized)
+        return null;
+    const now = Date.now();
+    const cached = readCachedWhois(normalized, now);
+    if (cached !== undefined)
+        return cached;
+    const cacheTtlMs = opts?.cacheTtlMs ?? 60_000;
+    const errorTtlMs = opts?.errorTtlMs ?? 5_000;
+    try {
+        const tailscaleBin = await getTailscaleBinary();
+        const { stdout } = await exec(tailscaleBin, ["whois", "--json", normalized], {
+            timeoutMs: opts?.timeoutMs ?? 5_000,
+            maxBuffer: 200_000,
+        });
+        const parsed = stdout ? parsePossiblyNoisyJsonObject(stdout) : {};
+        const identity = parseWhoisIdentity(parsed);
+        writeCachedWhois(normalized, identity, cacheTtlMs);
+        return identity;
+    }
+    catch {
+        writeCachedWhois(normalized, null, errorTtlMs);
+        return null;
+    }
+}

package/dist/infra/tls/gateway.js

@@ -36,7 +36,7 @@ async function generateSelfSignedCert(params) {
         "-out",
         params.certPath,
         "-subj",
-        "/CN=clawdbot-gateway",
+        "/CN=poolbot-gateway",
     ]);
     await fs.chmod(params.keyPath, 0o600).catch(() => { });
     await fs.chmod(params.certPath, 0o600).catch(() => { });

package/dist/infra/unhandled-rejections.js

@@ -1,6 +1,81 @@
 import process from "node:process";
 import { formatUncaughtError } from "./errors.js";
 const handlers = new Set();
+/**
+ * Checks if an error is an AbortError.
+ * These are typically intentional cancellations (e.g., during shutdown) and shouldn't crash.
+ */
+export function isAbortError(err) {
+    if (!err || typeof err !== "object")
+        return false;
+    const name = "name" in err ? String(err.name) : "";
+    if (name === "AbortError")
+        return true;
+    // Check for "This operation was aborted" message from Node's undici
+    const message = "message" in err && typeof err.message === "string" ? err.message : "";
+    if (message === "This operation was aborted")
+        return true;
+    return false;
+}
+// Network error codes that indicate transient failures (shouldn't crash the gateway)
+const TRANSIENT_NETWORK_CODES = new Set([
+    "ECONNRESET",
+    "ECONNREFUSED",
+    "ENOTFOUND",
+    "ETIMEDOUT",
+    "ESOCKETTIMEDOUT",
+    "ECONNABORTED",
+    "EPIPE",
+    "EHOSTUNREACH",
+    "ENETUNREACH",
+    "EAI_AGAIN",
+    "UND_ERR_CONNECT_TIMEOUT",
+    "UND_ERR_SOCKET",
+    "UND_ERR_HEADERS_TIMEOUT",
+    "UND_ERR_BODY_TIMEOUT",
+]);
+function getErrorCode(err) {
+    if (!err || typeof err !== "object")
+        return undefined;
+    const code = err.code;
+    return typeof code === "string" ? code : undefined;
+}
+function getErrorCause(err) {
+    if (!err || typeof err !== "object")
+        return undefined;
+    return err.cause;
+}
+/**
+ * Checks if an error is a transient network error that shouldn't crash the gateway.
+ * These are typically temporary connectivity issues that will resolve on their own.
+ */
+export function isTransientNetworkError(err) {
+    if (!err)
+        return false;
+    // Check the error itself
+    const code = getErrorCode(err);
+    if (code && TRANSIENT_NETWORK_CODES.has(code))
+        return true;
+    // "fetch failed" TypeError from undici (Node's native fetch)
+    if (err instanceof TypeError && err.message === "fetch failed") {
+        const cause = getErrorCause(err);
+        // The cause often contains the actual network error
+        if (cause)
+            return isTransientNetworkError(cause);
+        // Even without a cause, "fetch failed" is typically a network issue
+        return true;
+    }
+    // Check the cause chain recursively
+    const cause = getErrorCause(err);
+    if (cause && cause !== err) {
+        return isTransientNetworkError(cause);
+    }
+    // AggregateError may wrap multiple causes
+    if (err instanceof AggregateError && err.errors?.length) {
+        return err.errors.some((e) => isTransientNetworkError(e));
+    }
+    return false;
+}
 export function registerUnhandledRejectionHandler(handler) {
     handlers.add(handler);
     return () => {
@@ -14,7 +89,7 @@ export function isUnhandledRejectionHandled(reason) {
                 return true;
         }
         catch (err) {
-            console.error("[clawdbot] Unhandled rejection handler failed:", err instanceof Error ? (err.stack ?? err.message) : err);
+            console.error("[poolbot] Unhandled rejection handler failed:", err instanceof Error ? (err.stack ?? err.message) : err);
         }
     }
     return false;
@@ -23,7 +98,19 @@ export function installUnhandledRejectionHandler() {
     process.on("unhandledRejection", (reason, _promise) => {
         if (isUnhandledRejectionHandled(reason))
             return;
-        console.error("[clawdbot] Unhandled promise rejection:", formatUncaughtError(reason));
+        // AbortError is typically an intentional cancellation (e.g., during shutdown)
+        // Log it but don't crash - these are expected during graceful shutdown
+        if (isAbortError(reason)) {
+            console.warn("[poolbot] Suppressed AbortError:", formatUncaughtError(reason));
+            return;
+        }
+        // Transient network errors (fetch failed, connection reset, etc.) shouldn't crash
+        // These are temporary connectivity issues that will resolve on their own
+        if (isTransientNetworkError(reason)) {
+            console.error("[poolbot] Network error (non-fatal):", formatUncaughtError(reason));
+            return;
+        }
+        console.error("[poolbot] Unhandled promise rejection:", formatUncaughtError(reason));
         process.exit(1);
     });
 }

package/dist/infra/update-check.js

@@ -68,9 +68,7 @@ export async function checkGitUpdateStatus(params) {
     const tag = tagRes && tagRes.code === 0 ? tagRes.stdout.trim() : null;
     const upstreamRes = await runCommandWithTimeout(["git", "-C", root, "rev-parse", "--abbrev-ref", "@{upstream}"], { timeoutMs }).catch(() => null);
     const upstream = upstreamRes && upstreamRes.code === 0 ? upstreamRes.stdout.trim() : null;
-    const dirtyRes = await runCommandWithTimeout(["git", "-C", root, "status", "--porcelain"], {
-        timeoutMs,
-    }).catch(() => null);
+    const dirtyRes = await runCommandWithTimeout(["git", "-C", root, "status", "--porcelain", "--", ":!dist/control-ui/"], { timeoutMs }).catch(() => null);
     const dirty = dirtyRes && dirtyRes.code === 0 ? dirtyRes.stdout.trim().length > 0 : null;
     const fetchOk = params.fetch
         ? await runCommandWithTimeout(["git", "-C", root, "fetch", "--quiet", "--prune"], { timeoutMs })
@@ -216,7 +214,7 @@ export async function fetchNpmTagVersion(params) {
     const timeoutMs = params?.timeoutMs ?? 3500;
     const tag = params.tag;
     try {
-        const res = await fetchWithTimeout(`https://registry.npmjs.org/clawdbot/${encodeURIComponent(tag)}`, timeoutMs);
+        const res = await fetchWithTimeout(`https://registry.npmjs.org/poolbot/${encodeURIComponent(tag)}`, timeoutMs);
         if (!res.ok) {
             return { tag, version: null, error: `HTTP ${res.status}` };
         }

package/dist/infra/update-global.js

@@ -36,7 +36,7 @@ export async function resolveGlobalPackageRoot(manager, runCommand, timeoutMs) {
     const root = await resolveGlobalRoot(manager, runCommand, timeoutMs);
     if (!root)
         return null;
-    return path.join(root, "clawdbot");
+    return path.join(root, "poolbot");
 }
 export async function detectGlobalInstallManagerForRoot(runCommand, pkgRoot, timeoutMs) {
     const pkgReal = await tryRealpath(pkgRoot);
@@ -52,13 +52,13 @@ export async function detectGlobalInstallManagerForRoot(runCommand, pkgRoot, tim
         if (!globalRoot)
             continue;
         const globalReal = await tryRealpath(globalRoot);
-        const expected = path.join(globalReal, "clawdbot");
+        const expected = path.join(globalReal, "poolbot");
         if (path.resolve(expected) === path.resolve(pkgReal))
             return manager;
     }
     const bunGlobalRoot = resolveBunGlobalRoot();
     const bunGlobalReal = await tryRealpath(bunGlobalRoot);
-    const bunExpected = path.join(bunGlobalReal, "clawdbot");
+    const bunExpected = path.join(bunGlobalReal, "poolbot");
     if (path.resolve(bunExpected) === path.resolve(pkgReal))
         return "bun";
     return null;
@@ -68,11 +68,11 @@ export async function detectGlobalInstallManagerByPresence(runCommand, timeoutMs
         const root = await resolveGlobalRoot(manager, runCommand, timeoutMs);
         if (!root)
             continue;
-        if (await pathExists(path.join(root, "clawdbot")))
+        if (await pathExists(path.join(root, "poolbot")))
             return manager;
     }
     const bunRoot = resolveBunGlobalRoot();
-    if (await pathExists(path.join(bunRoot, "clawdbot")))
+    if (await pathExists(path.join(bunRoot, "poolbot")))
         return "bun";
     return null;
 }

package/dist/infra/update-runner.js

@@ -10,6 +10,8 @@ const DEFAULT_TIMEOUT_MS = 20 * 60_000;
 const MAX_LOG_CHARS = 8000;
 const PREFLIGHT_MAX_COMMITS = 10;
 const START_DIRS = ["cwd", "argv1", "process"];
+const DEFAULT_PACKAGE_NAME = "poolbot";
+const CORE_PACKAGE_NAMES = new Set([DEFAULT_PACKAGE_NAME, "poolbot"]);
 function normalizeDir(value) {
     if (!value)
         return null;
@@ -57,6 +59,17 @@ async function readPackageVersion(root) {
         return null;
     }
 }
+async function readPackageName(root) {
+    try {
+        const raw = await fs.readFile(path.join(root, "package.json"), "utf-8");
+        const parsed = JSON.parse(raw);
+        const name = parsed?.name?.trim();
+        return name ? name : null;
+    }
+    catch {
+        return null;
+    }
+}
 async function readBranchName(runCommand, root, timeoutMs) {
     const res = await runCommand(["git", "-C", root, "rev-parse", "--abbrev-ref", "HEAD"], {
         timeoutMs,
@@ -114,7 +127,8 @@ async function findPackageRoot(candidates) {
             try {
                 const raw = await fs.readFile(pkgPath, "utf-8");
                 const parsed = JSON.parse(raw);
-                if (parsed?.name === "clawdbot")
+                const name = parsed?.name?.trim();
+                if (name && CORE_PACKAGE_NAMES.has(name))
                     return current;
             }
             catch {
@@ -198,7 +212,12 @@ function normalizeTag(tag) {
     const trimmed = tag?.trim();
     if (!trimmed)
         return "latest";
-    return trimmed.startsWith("clawdbot@") ? trimmed.slice("clawdbot@".length) : trimmed;
+    if (trimmed.startsWith("poolbot@"))
+        return trimmed.slice("poolbot@".length);
+    if (trimmed.startsWith(`${DEFAULT_PACKAGE_NAME}@`)) {
+        return trimmed.slice(`${DEFAULT_PACKAGE_NAME}@`.length);
+    }
+    return trimmed;
 }
 export async function runGatewayUpdate(opts = {}) {
     const startedAt = Date.now();
@@ -238,7 +257,7 @@ export async function runGatewayUpdate(opts = {}) {
             status: "error",
             mode: "unknown",
             root: gitRoot,
-            reason: "not-clawdbot-root",
+            reason: "not-poolbot-root",
             steps: [],
             durationMs: Date.now() - startedAt,
         };
@@ -254,8 +273,8 @@ export async function runGatewayUpdate(opts = {}) {
         const channel = opts.channel ?? "dev";
         const branch = channel === "dev" ? await readBranchName(runCommand, gitRoot, timeoutMs) : null;
         const needsCheckoutMain = channel === "dev" && branch !== DEV_BRANCH;
-        gitTotalSteps = channel === "dev" ? (needsCheckoutMain ? 10 : 9) : 8;
-        const statusCheck = await runStep(step("clean check", ["git", "-C", gitRoot, "status", "--porcelain"], gitRoot));
+        gitTotalSteps = channel === "dev" ? (needsCheckoutMain ? 11 : 10) : 9;
+        const statusCheck = await runStep(step("clean check", ["git", "-C", gitRoot, "status", "--porcelain", "--", ":!dist/control-ui/"], gitRoot));
         steps.push(statusCheck);
         const hasUncommittedChanges = statusCheck.stdoutTail && statusCheck.stdoutTail.trim().length > 0;
         if (hasUncommittedChanges) {
@@ -351,7 +370,7 @@ export async function runGatewayUpdate(opts = {}) {
                 };
             }
             const manager = await detectPackageManager(gitRoot);
-            const preflightRoot = await fs.mkdtemp(path.join(os.tmpdir(), "clawdbot-update-preflight-"));
+            const preflightRoot = await fs.mkdtemp(path.join(os.tmpdir(), "poolbot-update-preflight-"));
             const worktreeDir = path.join(preflightRoot, "worktree");
             const worktreeStep = await runStep(step("preflight worktree", ["git", "-C", gitRoot, "worktree", "add", "--detach", worktreeDir, upstreamSha], gitRoot));
             steps.push(worktreeStep);
@@ -485,7 +504,11 @@ export async function runGatewayUpdate(opts = {}) {
         steps.push(buildStep);
         const uiBuildStep = await runStep(step("ui:build", managerScriptArgs(manager, "ui:build"), gitRoot));
         steps.push(uiBuildStep);
-        const doctorStep = await runStep(step("clawdbot doctor", managerScriptArgs(manager, "clawdbot", ["doctor", "--non-interactive"]), gitRoot, { CLAWDBOT_UPDATE_IN_PROGRESS: "1" }));
+        // Restore dist/control-ui/ to committed state to prevent dirty repo after update
+        // (ui:build regenerates assets with new hashes, which would block future updates)
+        const restoreUiStep = await runStep(step("restore control-ui", ["git", "-C", gitRoot, "checkout", "--", "dist/control-ui/"], gitRoot));
+        steps.push(restoreUiStep);
+        const doctorStep = await runStep(step("poolbot doctor", managerScriptArgs(manager, "poolbot", ["doctor", "--non-interactive"]), gitRoot, { CLAWDBOT_UPDATE_IN_PROGRESS: "1" }));
         steps.push(doctorStep);
         const failedStep = steps.find((s) => s.exitCode !== 0);
         const afterShaStep = await runStep(step("git rev-parse HEAD (after)", ["git", "-C", gitRoot, "rev-parse", "HEAD"], gitRoot));
@@ -517,7 +540,8 @@ export async function runGatewayUpdate(opts = {}) {
     const beforeVersion = await readPackageVersion(pkgRoot);
     const globalManager = await detectGlobalInstallManagerForRoot(runCommand, pkgRoot, timeoutMs);
     if (globalManager) {
-        const spec = `clawdbot@${normalizeTag(opts.tag)}`;
+        const packageName = (await readPackageName(pkgRoot)) ?? DEFAULT_PACKAGE_NAME;
+        const spec = `${packageName}@${normalizeTag(opts.tag)}`;
         const updateStep = await runStep({
             runCommand,
             name: "global update",

package/dist/infra/update-startup.js

@@ -1,7 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { resolveStateDir } from "../config/paths.js";
-import { resolveClawdbotPackageRoot } from "./clawdbot-root.js";
+import { resolvePoolBotPackageRoot } from "./poolbot-root.js";
 import { compareSemverStrings, resolveNpmChannelTag, checkUpdateStatus } from "./update-check.js";
 import { normalizeUpdateChannel, DEFAULT_PACKAGE_CHANNEL } from "./update-channels.js";
 import { VERSION } from "../version.js";
@@ -44,7 +44,7 @@ export async function runGatewayUpdateCheck(params) {
         if (now - lastCheckedAt < UPDATE_CHECK_INTERVAL_MS)
             return;
     }
-    const root = await resolveClawdbotPackageRoot({
+    const root = await resolvePoolBotPackageRoot({
         moduleUrl: import.meta.url,
         argv1: process.argv[1],
         cwd: process.cwd(),
@@ -74,7 +74,7 @@ export async function runGatewayUpdateCheck(params) {
     if (cmp != null && cmp < 0) {
         const shouldNotify = state.lastNotifiedVersion !== resolved.version || state.lastNotifiedTag !== tag;
         if (shouldNotify) {
-            params.log.info(`update available (${tag}): v${resolved.version} (current v${VERSION}). Run: ${formatCliCommand("clawdbot update")}`);
+            params.log.info(`update available (${tag}): v${resolved.version} (current v${VERSION}). Run: ${formatCliCommand("poolbot update")}`);
             nextState.lastNotifiedVersion = resolved.version;
             nextState.lastNotifiedTag = tag;
         }

package/dist/infra/warnings.js

@@ -1,4 +1,4 @@
-const warningFilterKey = Symbol.for("clawdbot.warning-filter");
+const warningFilterKey = Symbol.for("poolbot.warning-filter");
 function shouldIgnoreWarning(warning) {
     if (warning.code === "DEP0040" && warning.message?.includes("punycode")) {
         return true;

package/dist/infra/widearea-dns.js

@@ -2,8 +2,8 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { CONFIG_DIR, ensureDir } from "../utils.js";
-export const WIDE_AREA_DISCOVERY_DOMAIN = "clawdbot.internal.";
-export const WIDE_AREA_ZONE_FILENAME = "clawdbot.internal.db";
+export const WIDE_AREA_DISCOVERY_DOMAIN = "poolbot.internal.";
+export const WIDE_AREA_ZONE_FILENAME = "poolbot.internal.db";
 export function getWideAreaZonePath() {
     return path.join(CONFIG_DIR, "dns", WIDE_AREA_ZONE_FILENAME);
 }
@@ -45,7 +45,7 @@ function extractSerial(zoneText) {
     return Number.isFinite(parsed) ? parsed : null;
 }
 function extractContentHash(zoneText) {
-    const match = zoneText.match(/^\s*;\s*clawdbot-content-hash:\s*(\S+)\s*$/m);
+    const match = zoneText.match(/^\s*;\s*poolbot-content-hash:\s*(\S+)\s*$/m);
     return match?.[1] ?? null;
 }
 function computeContentHash(body) {
@@ -58,9 +58,9 @@ function computeContentHash(body) {
     return (h >>> 0).toString(16).padStart(8, "0");
 }
 function renderZone(opts) {
-    const hostname = os.hostname().split(".")[0] ?? "clawdbot";
-    const hostLabel = dnsLabel(opts.hostLabel ?? hostname, "clawdbot");
-    const instanceLabel = dnsLabel(opts.instanceLabel ?? `${hostname}-gateway`, "clawdbot-gw");
+    const hostname = os.hostname().split(".")[0] ?? "poolbot";
+    const hostLabel = dnsLabel(opts.hostLabel ?? hostname, "poolbot");
+    const instanceLabel = dnsLabel(opts.instanceLabel ?? `${hostname}-gateway`, "poolbot-gw");
     const txt = [
         `displayName=${opts.displayName.trim() || hostname}`,
         `role=gateway`,
@@ -93,15 +93,15 @@ function renderZone(opts) {
     if (opts.tailnetIPv6) {
         records.push(`${hostLabel} IN AAAA ${opts.tailnetIPv6}`);
     }
-    records.push(`_clawdbot-gw._tcp IN PTR ${instanceLabel}._clawdbot-gw._tcp`);
-    records.push(`${instanceLabel}._clawdbot-gw._tcp IN SRV 0 0 ${opts.gatewayPort} ${hostLabel}`);
-    records.push(`${instanceLabel}._clawdbot-gw._tcp IN TXT ${txt.map(txtQuote).join(" ")}`);
+    records.push(`_poolbot-gw._tcp IN PTR ${instanceLabel}._poolbot-gw._tcp`);
+    records.push(`${instanceLabel}._poolbot-gw._tcp IN SRV 0 0 ${opts.gatewayPort} ${hostLabel}`);
+    records.push(`${instanceLabel}._poolbot-gw._tcp IN TXT ${txt.map(txtQuote).join(" ")}`);
     const contentBody = `${records.join("\n")}\n`;
     const hashBody = `${records
         .map((line) => line === soaLine ? `@ IN SOA ns1 hostmaster SERIAL 7200 3600 1209600 60` : line)
         .join("\n")}\n`;
     const contentHash = computeContentHash(hashBody);
-    return `; clawdbot-content-hash: ${contentHash}\n${contentBody}`;
+    return `; poolbot-content-hash: ${contentHash}\n${contentBody}`;
 }
 export function renderWideAreaGatewayZoneText(opts) {
     return renderZone(opts);

package/dist/line/monitor.js

@@ -1,6 +1,6 @@
-import crypto from "node:crypto";
 import { danger, logVerbose } from "../globals.js";
 import { createLineBot } from "./bot.js";
+import { validateLineSignature } from "./signature.js";
 import { normalizePluginHttpPath } from "../plugins/http-path.js";
 import { registerPluginHttpRoute } from "../plugins/http-registry.js";
 import { replyMessageLine, showLoadingAnimation, getUserDisplayName, createQuickReplyItems, createTextMessageWithQuickReplies, pushTextMessageWithQuickReplies, pushMessageLine, pushMessagesLine, createFlexMessage, createImageMessage, createLocationMessage, } from "./send.js";
@@ -26,10 +26,6 @@ function recordChannelRuntimeState(params) {
 export function getLineRuntimeState(accountId) {
     return runtimeState.get(`line:${accountId}`);
 }
-function validateLineSignature(body, signature, channelSecret) {
-    const hash = crypto.createHmac("SHA256", channelSecret).update(body).digest("base64");
-    return hash === signature;
-}
 async function readRequestBody(req) {
     return new Promise((resolve, reject) => {
         const chunks = [];