@poolzin/pool-bot 2026.2.24 → 2026.2.26

package/dist/auto-reply/status.js

@@ -2,9 +2,11 @@ import fs from "node:fs";
 import { lookupContextTokens } from "../agents/context.js";
 import { DEFAULT_CONTEXT_TOKENS, DEFAULT_MODEL, DEFAULT_PROVIDER } from "../agents/defaults.js";
 import { resolveModelAuthMode } from "../agents/model-auth.js";
-import { resolveConfiguredModelRef } from "../agents/model-selection.js";
+import { buildModelAliasIndex, resolveConfiguredModelRef, resolveModelRefFromString, } from "../agents/model-selection.js";
 import { resolveSandboxRuntimeStatus } from "../agents/sandbox.js";
 import { derivePromptTokens, normalizeUsage } from "../agents/usage.js";
+import { resolveChannelModelOverride } from "../channels/model-overrides.js";
+import { isCommandFlagEnabled } from "../config/commands.js";
 import { resolveMainSessionKey, resolveSessionFilePath, resolveSessionFilePathOptions, } from "../config/sessions.js";
 import { formatTimeAgo } from "../infra/format-time/format-relative.js";
 import { resolveCommitHash } from "../infra/git-commit.js";
@@ -14,7 +16,34 @@ import { getTtsMaxLength, getTtsProvider, isSummarizationEnabled, resolveTtsAuto
 import { estimateUsageCost, formatTokenCount as formatTokenCountShared, formatUsd, resolveModelCostConfig, } from "../utils/usage-format.js";
 import { VERSION } from "../version.js";
 import { listChatCommands, listChatCommandsForConfig, } from "./commands-registry.js";
+import { resolveActiveFallbackState } from "./fallback-state.js";
+import { formatProviderModelRef, resolveSelectedAndActiveModel } from "./model-runtime.js";
 export const formatTokenCount = formatTokenCountShared;
+function normalizeAuthMode(value) {
+    const normalized = value?.trim().toLowerCase();
+    if (!normalized) {
+        return undefined;
+    }
+    if (normalized === "api-key" || normalized.startsWith("api-key ")) {
+        return "api-key";
+    }
+    if (normalized === "oauth" || normalized.startsWith("oauth ")) {
+        return "oauth";
+    }
+    if (normalized === "token" || normalized.startsWith("token ")) {
+        return "token";
+    }
+    if (normalized === "aws-sdk" || normalized.startsWith("aws-sdk ")) {
+        return "aws-sdk";
+    }
+    if (normalized === "mixed" || normalized.startsWith("mixed ")) {
+        return "mixed";
+    }
+    if (normalized === "unknown") {
+        return "unknown";
+    }
+    return undefined;
+}
 function resolveRuntimeLabel(args) {
     const sessionKey = args.sessionKey?.trim();
     if (args.config && sessionKey) {
@@ -156,6 +185,24 @@ const formatUsagePair = (input, output) => {
     const outputLabel = typeof output === "number" ? formatTokenCount(output) : "?";
     return `🧮 Tokens: ${inputLabel} in / ${outputLabel} out`;
 };
+const formatCacheLine = (input, cacheRead, cacheWrite) => {
+    if (!cacheRead && !cacheWrite) {
+        return null;
+    }
+    if ((typeof cacheRead !== "number" || cacheRead <= 0) &&
+        (typeof cacheWrite !== "number" || cacheWrite <= 0)) {
+        return null;
+    }
+    const cachedLabel = typeof cacheRead === "number" ? formatTokenCount(cacheRead) : "0";
+    const newLabel = typeof cacheWrite === "number" ? formatTokenCount(cacheWrite) : "0";
+    const totalInput = (typeof cacheRead === "number" ? cacheRead : 0) +
+        (typeof cacheWrite === "number" ? cacheWrite : 0) +
+        (typeof input === "number" ? input : 0);
+    const hitRate = totalInput > 0 && typeof cacheRead === "number"
+        ? Math.round((cacheRead / totalInput) * 100)
+        : 0;
+    return `🗄️ Cache: ${hitRate}% hit · ${cachedLabel} cached, ${newLabel} new`;
+};
 const formatMediaUnderstandingLine = (decisions) => {
     if (!decisions || decisions.length === 0) {
         return null;
@@ -229,14 +276,23 @@ export function buildStatusMessage(args) {
         defaultProvider: DEFAULT_PROVIDER,
         defaultModel: DEFAULT_MODEL,
     });
-    const provider = entry?.providerOverride ?? resolved.provider ?? DEFAULT_PROVIDER;
-    let model = entry?.modelOverride ?? resolved.model ?? DEFAULT_MODEL;
+    const selectedProvider = entry?.providerOverride ?? resolved.provider ?? DEFAULT_PROVIDER;
+    const selectedModel = entry?.modelOverride ?? resolved.model ?? DEFAULT_MODEL;
+    const modelRefs = resolveSelectedAndActiveModel({
+        selectedProvider,
+        selectedModel,
+        sessionEntry: entry,
+    });
+    let activeProvider = modelRefs.active.provider;
+    let activeModel = modelRefs.active.model;
     let contextTokens = entry?.contextTokens ??
         args.agent?.contextTokens ??
-        lookupContextTokens(model) ??
+        lookupContextTokens(activeModel) ??
         DEFAULT_CONTEXT_TOKENS;
     let inputTokens = entry?.inputTokens;
     let outputTokens = entry?.outputTokens;
+    let cacheRead = entry?.cacheRead;
+    let cacheWrite = entry?.cacheWrite;
     let totalTokens = entry?.totalTokens ?? (entry?.inputTokens ?? 0) + (entry?.outputTokens ?? 0);
     // Prefer prompt-size tokens from the session transcript when it looks larger
     // (cached prompt tokens are often missing from agent meta/store).
@@ -247,8 +303,19 @@ export function buildStatusMessage(args) {
             if (!totalTokens || totalTokens === 0 || candidate > totalTokens) {
                 totalTokens = candidate;
             }
-            if (!model) {
-                model = logUsage.model ?? model;
+            if (!entry?.model && logUsage.model) {
+                const slashIndex = logUsage.model.indexOf("/");
+                if (slashIndex > 0) {
+                    const provider = logUsage.model.slice(0, slashIndex).trim();
+                    const model = logUsage.model.slice(slashIndex + 1).trim();
+                    if (provider && model) {
+                        activeProvider = provider;
+                        activeModel = model;
+                    }
+                }
+                else {
+                    activeModel = logUsage.model;
+                }
             }
             if (!contextTokens && logUsage.model) {
                 contextTokens = lookupContextTokens(logUsage.model) ?? contextTokens;
@@ -310,13 +377,27 @@ export function buildStatusMessage(args) {
         `🪢 Queue: ${queueMode}${queueDetails}`,
     ];
     const activationLine = activationParts.filter(Boolean).join(" · ");
-    const authMode = resolveModelAuthMode(provider, args.config);
-    const authLabelValue = args.modelAuth ?? (authMode && authMode !== "unknown" ? authMode : undefined);
-    const showCost = authLabelValue === "api-key" || authLabelValue === "mixed";
+    const selectedAuthMode = normalizeAuthMode(args.modelAuth) ?? resolveModelAuthMode(selectedProvider, args.config);
+    const selectedAuthLabelValue = args.modelAuth ??
+        (selectedAuthMode && selectedAuthMode !== "unknown" ? selectedAuthMode : undefined);
+    const activeAuthMode = normalizeAuthMode(args.activeModelAuth) ?? resolveModelAuthMode(activeProvider, args.config);
+    const activeAuthLabelValue = args.activeModelAuth ??
+        (activeAuthMode && activeAuthMode !== "unknown" ? activeAuthMode : undefined);
+    const selectedModelLabel = modelRefs.selected.label || "unknown";
+    const activeModelLabel = formatProviderModelRef(activeProvider, activeModel) || "unknown";
+    const fallbackState = resolveActiveFallbackState({
+        selectedModelRef: selectedModelLabel,
+        activeModelRef: activeModelLabel,
+        state: entry,
+    });
+    const effectiveCostAuthMode = fallbackState.active
+        ? activeAuthMode
+        : (selectedAuthMode ?? activeAuthMode);
+    const showCost = effectiveCostAuthMode === "api-key" || effectiveCostAuthMode === "mixed";
     const costConfig = showCost
         ? resolveModelCostConfig({
-            provider,
-            model,
+            provider: activeProvider,
+            model: activeModel,
             config: args.config,
         })
         : undefined;
@@ -331,12 +412,53 @@ export function buildStatusMessage(args) {
         })
         : undefined;
     const costLabel = showCost && hasUsage ? formatUsd(cost) : undefined;
-    const modelLabel = model ? `${provider}/${model}` : "unknown";
-    const authLabel = authLabelValue ? ` · 🔑 ${authLabelValue}` : "";
-    const modelLine = `🧠 Model: ${modelLabel}${authLabel}`;
+    const selectedAuthLabel = selectedAuthLabelValue ? ` · 🔑 ${selectedAuthLabelValue}` : "";
+    const channelModelNote = (() => {
+        if (!args.config || !entry) {
+            return undefined;
+        }
+        if (entry.modelOverride?.trim() || entry.providerOverride?.trim()) {
+            return undefined;
+        }
+        const channelOverride = resolveChannelModelOverride({
+            cfg: args.config,
+            channel: entry.channel ?? entry.origin?.provider,
+            groupId: entry.groupId,
+            groupChannel: entry.groupChannel,
+            groupSubject: entry.subject,
+            parentSessionKey: args.parentSessionKey,
+        });
+        if (!channelOverride) {
+            return undefined;
+        }
+        const aliasIndex = buildModelAliasIndex({
+            cfg: args.config,
+            defaultProvider: DEFAULT_PROVIDER,
+        });
+        const resolvedOverride = resolveModelRefFromString({
+            raw: channelOverride.model,
+            defaultProvider: DEFAULT_PROVIDER,
+            aliasIndex,
+        });
+        if (!resolvedOverride) {
+            return undefined;
+        }
+        if (resolvedOverride.ref.provider !== selectedProvider ||
+            resolvedOverride.ref.model !== selectedModel) {
+            return undefined;
+        }
+        return "channel override";
+    })();
+    const modelNote = channelModelNote ? ` · ${channelModelNote}` : "";
+    const modelLine = `🧠 Model: ${selectedModelLabel}${selectedAuthLabel}${modelNote}`;
+    const showFallbackAuth = activeAuthLabelValue && activeAuthLabelValue !== selectedAuthLabelValue;
+    const fallbackLine = fallbackState.active
+        ? `↪️ Fallback: ${activeModelLabel}${showFallbackAuth ? ` · 🔑 ${activeAuthLabelValue}` : ""} (${fallbackState.reason ?? "selected model unavailable"})`
+        : null;
     const commit = resolveCommitHash();
     const versionLine = `🦞 Pool Bot ${VERSION}${commit ? ` (${commit})` : ""}`;
     const usagePair = formatUsagePair(inputTokens, outputTokens);
+    const cacheLine = formatCacheLine(inputTokens, cacheRead, cacheWrite);
     const costLine = costLabel ? `💵 Cost: ${costLabel}` : null;
     const usageCostLine = usagePair && costLine ? `${usagePair} · ${costLine}` : (usagePair ?? costLine);
     const mediaLine = formatMediaUnderstandingLine(args.mediaDecisions);
@@ -345,7 +467,9 @@ export function buildStatusMessage(args) {
         versionLine,
         args.timeLine,
         modelLine,
+        fallbackLine,
         usageCostLine,
+        cacheLine,
         `📚 ${contextLine}`,
         mediaLine,
         args.usageLine,
@@ -395,10 +519,10 @@ export function buildHelpMessage(cfg) {
     lines.push("  /new  |  /reset  |  /compact [instructions]  |  /stop");
     lines.push("");
     const optionParts = ["/think <level>", "/model <id>", "/verbose on|off"];
-    if (cfg?.commands?.config === true) {
+    if (isCommandFlagEnabled(cfg, "config")) {
         optionParts.push("/config");
     }
-    if (cfg?.commands?.debug === true) {
+    if (isCommandFlagEnabled(cfg, "debug")) {
         optionParts.push("/debug");
     }
     lines.push("Options");

package/dist/auto-reply/templating.js

@@ -1,8 +1,10 @@
 function formatTemplateValue(value) {
-    if (value == null)
+    if (value == null) {
         return "";
-    if (typeof value === "string")
+    }
+    if (typeof value === "string") {
         return value;
+    }
     if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
         return String(value);
     }
@@ -12,10 +14,12 @@ function formatTemplateValue(value) {
     if (Array.isArray(value)) {
         return value
             .flatMap((entry) => {
-            if (entry == null)
+            if (entry == null) {
                 return [];
-            if (typeof entry === "string")
+            }
+            if (typeof entry === "string") {
                 return [entry];
+            }
             if (typeof entry === "number" || typeof entry === "boolean" || typeof entry === "bigint") {
                 return [String(entry)];
             }
@@ -30,8 +34,9 @@ function formatTemplateValue(value) {
 }
 // Simple {{Placeholder}} interpolation using inbound message context.
 export function applyTemplate(str, ctx) {
-    if (!str)
+    if (!str) {
         return "";
+    }
     return str.replace(/{{\s*(\w+)\s*}}/g, (_, key) => {
         const value = ctx[key];
         return formatTemplateValue(value);

package/dist/auto-reply/thinking.js

@@ -14,6 +14,7 @@ export function isBinaryThinkingProvider(provider) {
 export const XHIGH_MODEL_REFS = [
     "openai/gpt-5.2",
     "openai-codex/gpt-5.3-codex",
+    "openai-codex/gpt-5.3-codex-spark",
     "openai-codex/gpt-5.2-codex",
     "openai-codex/gpt-5.1-codex",
     "github-copilot/gpt-5.2-codex",
@@ -94,8 +95,7 @@ export function formatXHighModelHint() {
     }
     return `${refs.slice(0, -1).join(", ")} or ${refs[refs.length - 1]}`;
 }
-// Normalize verbose flags used to toggle agent verbosity.
-export function normalizeVerboseLevel(raw) {
+function normalizeOnOffFullLevel(raw) {
     if (!raw) {
         return undefined;
     }
@@ -111,22 +111,13 @@ export function normalizeVerboseLevel(raw) {
     }
     return undefined;
 }
+// Normalize verbose flags used to toggle agent verbosity.
+export function normalizeVerboseLevel(raw) {
+    return normalizeOnOffFullLevel(raw);
+}
 // Normalize system notice flags used to toggle system notifications.
 export function normalizeNoticeLevel(raw) {
-    if (!raw) {
-        return undefined;
-    }
-    const key = raw.toLowerCase();
-    if (["off", "false", "no", "0"].includes(key)) {
-        return "off";
-    }
-    if (["full", "all", "everything"].includes(key)) {
-        return "full";
-    }
-    if (["on", "minimal", "true", "yes", "1"].includes(key)) {
-        return "on";
-    }
-    return undefined;
+    return normalizeOnOffFullLevel(raw);
 }
 // Normalize response-usage display modes used to toggle per-response usage footers.
 export function normalizeUsageDisplay(raw) {

package/dist/auto-reply/tokens.js

@@ -1,15 +1,31 @@
+import { escapeRegExp } from "../utils.js";
 export const HEARTBEAT_TOKEN = "HEARTBEAT_OK";
 export const SILENT_REPLY_TOKEN = "NO_REPLY";
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 export function isSilentReplyText(text, token = SILENT_REPLY_TOKEN) {
-    if (!text)
+    if (!text) {
         return false;
+    }
     const escaped = escapeRegExp(token);
     const prefix = new RegExp(`^\\s*${escaped}(?=$|\\W)`);
-    if (prefix.test(text))
+    if (prefix.test(text)) {
         return true;
+    }
     const suffix = new RegExp(`\\b${escaped}\\b\\W*$`);
     return suffix.test(text);
 }
+export function isSilentReplyPrefixText(text, token = SILENT_REPLY_TOKEN) {
+    if (!text) {
+        return false;
+    }
+    const normalized = text.trimStart().toUpperCase();
+    if (!normalized) {
+        return false;
+    }
+    if (!normalized.includes("_")) {
+        return false;
+    }
+    if (/[^A-Z_]/.test(normalized)) {
+        return false;
+    }
+    return token.toUpperCase().startsWith(normalized);
+}

package/dist/browser/bridge-server.js

@@ -1,33 +1,39 @@
 import express from "express";
+import { isLoopbackHost } from "../gateway/net.js";
+import { deleteBridgeAuthForPort, setBridgeAuthForPort } from "./bridge-auth-registry.js";
 import { registerBrowserRoutes } from "./routes/index.js";
 import { createBrowserRouteContext, } from "./server-context.js";
+import { installBrowserAuthMiddleware, installBrowserCommonMiddleware, } from "./server-middleware.js";
 export async function startBrowserBridgeServer(params) {
     const host = params.host ?? "127.0.0.1";
+    if (!isLoopbackHost(host)) {
+        throw new Error(`bridge server must bind to loopback host (got ${host})`);
+    }
     const port = params.port ?? 0;
     const app = express();
-    app.use(express.json({ limit: "1mb" }));
-    app.use((req, res, next) => {
-        const ctrl = new AbortController();
-        const abort = () => ctrl.abort(new Error("request aborted"));
-        req.once("aborted", abort);
-        res.once("close", () => {
-            if (!res.writableEnded) {
-                abort();
+    installBrowserCommonMiddleware(app);
+    if (params.resolveSandboxNoVncToken) {
+        app.get("/sandbox/novnc", (req, res) => {
+            const rawToken = typeof req.query?.token === "string" ? req.query.token.trim() : "";
+            if (!rawToken) {
+                res.status(400).send("Missing token");
+                return;
             }
-        });
-        // Make the signal available to browser route handlers (best-effort).
-        req.signal = ctrl.signal;
-        next();
-    });
-    const authToken = params.authToken?.trim();
-    if (authToken) {
-        app.use((req, res, next) => {
-            const auth = String(req.headers.authorization ?? "").trim();
-            if (auth === `Bearer ${authToken}`)
-                return next();
-            res.status(401).send("Unauthorized");
+            const redirectUrl = params.resolveSandboxNoVncToken?.(rawToken);
+            if (!redirectUrl) {
+                res.status(404).send("Invalid or expired token");
+                return;
+            }
+            res.setHeader("Cache-Control", "no-store");
+            res.redirect(302, redirectUrl);
         });
     }
+    const authToken = params.authToken?.trim() || undefined;
+    const authPassword = params.authPassword?.trim() || undefined;
+    if (!authToken && !authPassword) {
+        throw new Error("bridge server requires auth (authToken/authPassword missing)");
+    }
+    installBrowserAuthMiddleware(app, { token: authToken, password: authPassword });
     const state = {
         server: null,
         port,
@@ -48,10 +54,20 @@ export async function startBrowserBridgeServer(params) {
     state.server = server;
     state.port = resolvedPort;
     state.resolved.controlPort = resolvedPort;
+    setBridgeAuthForPort(resolvedPort, { token: authToken, password: authPassword });
     const baseUrl = `http://${host}:${resolvedPort}`;
     return { server, port: resolvedPort, baseUrl, state };
 }
 export async function stopBrowserBridgeServer(server) {
+    try {
+        const address = server.address();
+        if (address?.port) {
+            deleteBridgeAuthForPort(address.port);
+        }
+    }
+    catch {
+        // ignore
+    }
     await new Promise((resolve) => {
         server.close(() => resolve());
     });

package/dist/browser/cdp.helpers.js

@@ -82,33 +82,26 @@ function createCdpSender(ws) {
     return { send, closeWithError };
 }
 export async function fetchJson(url, timeoutMs = 1500, init) {
+    const res = await fetchChecked(url, timeoutMs, init);
+    return (await res.json());
+}
+async function fetchChecked(url, timeoutMs = 1500, init) {
     const ctrl = new AbortController();
-    const t = setTimeout(() => ctrl.abort(), timeoutMs);
+    const t = setTimeout(ctrl.abort.bind(ctrl), timeoutMs);
     try {
         const headers = getHeadersWithAuth(url, init?.headers || {});
         const res = await fetch(url, { ...init, headers, signal: ctrl.signal });
         if (!res.ok) {
             throw new Error(`HTTP ${res.status}`);
         }
-        return (await res.json());
+        return res;
     }
     finally {
         clearTimeout(t);
     }
 }
 export async function fetchOk(url, timeoutMs = 1500, init) {
-    const ctrl = new AbortController();
-    const t = setTimeout(() => ctrl.abort(), timeoutMs);
-    try {
-        const headers = getHeadersWithAuth(url, init?.headers || {});
-        const res = await fetch(url, { ...init, headers, signal: ctrl.signal });
-        if (!res.ok) {
-            throw new Error(`HTTP ${res.status}`);
-        }
-    }
-    finally {
-        clearTimeout(t);
-    }
+    await fetchChecked(url, timeoutMs, init);
 }
 export async function withCdpSocket(wsUrl, fn, opts) {
     const headers = getHeadersWithAuth(wsUrl, opts?.headers ?? {});

package/dist/browser/cdp.js

@@ -1,4 +1,5 @@
 import { appendCdpPath, fetchJson, isLoopbackHost, withCdpSocket } from "./cdp.helpers.js";
+import { assertBrowserNavigationAllowed, withBrowserNavigationPolicy } from "./navigation-guard.js";
 export { appendCdpPath, fetchJson, fetchOk, getHeadersWithAuth } from "./cdp.helpers.js";
 export function normalizeCdpWsUrl(wsUrl, cdpUrl) {
     const ws = new URL(wsUrl);
@@ -6,8 +7,9 @@ export function normalizeCdpWsUrl(wsUrl, cdpUrl) {
     if (isLoopbackHost(ws.hostname) && !isLoopbackHost(cdp.hostname)) {
         ws.hostname = cdp.hostname;
         const cdpPort = cdp.port || (cdp.protocol === "https:" ? "443" : "80");
-        if (cdpPort)
+        if (cdpPort) {
             ws.port = cdpPort;
+        }
         ws.protocol = cdp.protocol === "https:" ? "wss:" : "ws:";
     }
     if (cdp.protocol === "https:" && ws.protocol === "ws:") {
@@ -18,8 +20,9 @@ export function normalizeCdpWsUrl(wsUrl, cdpUrl) {
         ws.password = cdp.password;
     }
     for (const [key, value] of cdp.searchParams.entries()) {
-        if (!ws.searchParams.has(key))
+        if (!ws.searchParams.has(key)) {
             ws.searchParams.append(key, value);
+        }
     }
     return ws.toString();
 }
@@ -53,22 +56,29 @@ export async function captureScreenshot(opts) {
             ...(clip ? { clip } : {}),
         }));
         const base64 = result?.data;
-        if (!base64)
+        if (!base64) {
             throw new Error("Screenshot failed: missing data");
+        }
         return Buffer.from(base64, "base64");
     });
 }
 export async function createTargetViaCdp(opts) {
+    await assertBrowserNavigationAllowed({
+        url: opts.url,
+        ...withBrowserNavigationPolicy(opts.ssrfPolicy),
+    });
     const version = await fetchJson(appendCdpPath(opts.cdpUrl, "/json/version"), 1500);
     const wsUrlRaw = String(version?.webSocketDebuggerUrl ?? "").trim();
     const wsUrl = wsUrlRaw ? normalizeCdpWsUrl(wsUrlRaw, opts.cdpUrl) : "";
-    if (!wsUrl)
+    if (!wsUrl) {
         throw new Error("CDP /json/version missing webSocketDebuggerUrl");
+    }
     return await withCdpSocket(wsUrl, async (send) => {
         const created = (await send("Target.createTarget", { url: opts.url }));
         const targetId = String(created?.targetId ?? "").trim();
-        if (!targetId)
+        if (!targetId) {
             throw new Error("CDP Target.createTarget returned no targetId");
+        }
         return { targetId };
     });
 }
@@ -83,17 +93,20 @@ export async function evaluateJavaScript(opts) {
             includeCommandLineAPI: true,
         }));
         const result = evaluated?.result;
-        if (!result)
+        if (!result) {
             throw new Error("CDP Runtime.evaluate returned no result");
+        }
         return { result, exceptionDetails: evaluated.exceptionDetails };
     });
 }
 function axValue(v) {
-    if (!v || typeof v !== "object")
+    if (!v || typeof v !== "object") {
         return "";
+    }
     const value = v.value;
-    if (typeof value === "string")
+    if (typeof value === "string") {
         return value;
+    }
     if (typeof value === "number" || typeof value === "boolean") {
         return String(value);
     }
@@ -102,28 +115,33 @@ function axValue(v) {
 export function formatAriaSnapshot(nodes, limit) {
     const byId = new Map();
     for (const n of nodes) {
-        if (n.nodeId)
+        if (n.nodeId) {
             byId.set(n.nodeId, n);
+        }
     }
     // Heuristic: pick a root-ish node (one that is not referenced as a child), else first.
     const referenced = new Set();
     for (const n of nodes) {
-        for (const c of n.childIds ?? [])
+        for (const c of n.childIds ?? []) {
             referenced.add(c);
+        }
     }
     const root = nodes.find((n) => n.nodeId && !referenced.has(n.nodeId)) ?? nodes[0];
-    if (!root?.nodeId)
+    if (!root?.nodeId) {
         return [];
+    }
     const out = [];
     const stack = [{ id: root.nodeId, depth: 0 }];
     while (stack.length && out.length < limit) {
         const popped = stack.pop();
-        if (!popped)
+        if (!popped) {
             break;
+        }
         const { id, depth } = popped;
         const n = byId.get(id);
-        if (!n)
+        if (!n) {
             continue;
+        }
         const role = axValue(n.role);
         const name = axValue(n.name);
         const value = axValue(n.value);
@@ -141,8 +159,9 @@ export function formatAriaSnapshot(nodes, limit) {
         const children = (n.childIds ?? []).filter((c) => byId.has(c));
         for (let i = children.length - 1; i >= 0; i--) {
             const child = children[i];
-            if (child)
+            if (child) {
                 stack.push({ id: child, depth: depth + 1 });
+            }
         }
     }
     return out;
@@ -210,8 +229,9 @@ export async function snapshotDom(opts) {
         returnByValue: true,
     });
     const value = evaluated.result?.value;
-    if (!value || typeof value !== "object")
+    if (!value || typeof value !== "object") {
         return { nodes: [] };
+    }
     const nodes = value.nodes;
     return { nodes: Array.isArray(nodes) ? nodes : [] };
 }

package/dist/browser/chrome.profile-decoration.js

@@ -2,16 +2,18 @@ import fs from "node:fs";
 import path from "node:path";
 import { DEFAULT_CLAWD_BROWSER_COLOR, DEFAULT_CLAWD_BROWSER_PROFILE_NAME } from "./constants.js";
 function decoratedMarkerPath(userDataDir) {
-    return path.join(userDataDir, ".clawd-profile-decorated");
+    return path.join(userDataDir, ".poolbot-profile-decorated");
 }
 function safeReadJson(filePath) {
     try {
-        if (!fs.existsSync(filePath))
+        if (!fs.existsSync(filePath)) {
             return null;
+        }
         const raw = fs.readFileSync(filePath, "utf-8");
         const parsed = JSON.parse(raw);
-        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
             return null;
+        }
         return parsed;
     }
     catch {
@@ -35,8 +37,9 @@ function setDeep(obj, keys, value) {
 }
 function parseHexRgbToSignedArgbInt(hex) {
     const cleaned = hex.trim().replace(/^#/, "");
-    if (!/^[0-9a-fA-F]{6}$/.test(cleaned))
+    if (!/^[0-9a-fA-F]{6}$/.test(cleaned)) {
         return null;
+    }
     const rgb = Number.parseInt(cleaned, 16);
     const argbUnsigned = (0xff << 24) | rgb;
     // Chrome stores colors as signed 32-bit ints (SkColor).