@poolzin/pool-bot 2026.2.21 → 2026.2.22

package/dist/auto-reply/reply/session.js

@@ -3,26 +3,30 @@ import fs from "node:fs";
 import path from "node:path";
 import { CURRENT_SESSION_VERSION, SessionManager } from "@mariozechner/pi-coding-agent";
 import { resolveSessionAgentId } from "../../agents/agent-scope.js";
+import { normalizeChatType } from "../../channels/chat-type.js";
 import { DEFAULT_RESET_TRIGGERS, deriveSessionMetaPatch, evaluateSessionFreshness, loadSessionStore, resolveChannelResetConfig, resolveThreadFlag, resolveSessionResetPolicy, resolveSessionResetType, resolveGroupSessionKey, resolveSessionFilePath, resolveSessionKey, resolveSessionTranscriptPath, resolveStorePath, updateSessionStore, } from "../../config/sessions.js";
+import { archiveSessionTranscripts } from "../../gateway/session-utils.fs.js";
+import { deliverSessionMaintenanceWarning } from "../../infra/session-maintenance-warning.js";
+import { getGlobalHookRunner } from "../../plugins/hook-runner-global.js";
 import { normalizeMainKey } from "../../routing/session-key.js";
+import { normalizeSessionDeliveryFields } from "../../utils/delivery-context.js";
 import { resolveCommandAuthorization } from "../command-auth.js";
-import { normalizeChatType } from "../../channels/chat-type.js";
-import { stripMentions, stripStructuralPrefixes } from "./mentions.js";
-import { formatInboundBodyWithSenderMeta } from "./inbound-sender-meta.js";
 import { normalizeInboundTextNewlines } from "./inbound-text.js";
-import { normalizeSessionDeliveryFields } from "../../utils/delivery-context.js";
+import { stripMentions, stripStructuralPrefixes } from "./mentions.js";
 function forkSessionFromParent(params) {
-    const parentSessionFile = resolveSessionFilePath(params.parentEntry.sessionId, params.parentEntry);
-    if (!parentSessionFile || !fs.existsSync(parentSessionFile))
+    const parentSessionFile = resolveSessionFilePath(params.parentEntry.sessionId, params.parentEntry, { agentId: params.agentId, sessionsDir: params.sessionsDir });
+    if (!parentSessionFile || !fs.existsSync(parentSessionFile)) {
         return null;
+    }
     try {
         const manager = SessionManager.open(parentSessionFile);
         const leafId = manager.getLeafId();
         if (leafId) {
             const sessionFile = manager.createBranchedSession(leafId) ?? manager.getSessionFile();
             const sessionId = manager.getSessionId();
-            if (sessionFile && sessionId)
+            if (sessionFile && sessionId) {
                 return { sessionId, sessionFile };
+            }
         }
         const sessionId = crypto.randomUUID();
         const timestamp = new Date().toISOString();
@@ -63,7 +67,13 @@ export async function initSessionState(params) {
         : DEFAULT_RESET_TRIGGERS;
     const sessionScope = sessionCfg?.scope ?? "per-sender";
     const storePath = resolveStorePath(sessionCfg?.store, { agentId });
-    const sessionStore = loadSessionStore(storePath);
+    // CRITICAL: Skip cache to ensure fresh data when resolving session identity.
+    // Stale cache (especially with multiple gateway processes or on Windows where
+    // mtime granularity may miss rapid writes) can cause incorrect sessionId
+    // generation, leading to orphaned transcript files. See #17971.
+    const sessionStore = loadSessionStore(storePath, {
+        skipCache: true,
+    });
     let sessionKey;
     let sessionEntry;
     let sessionId;
@@ -106,10 +116,12 @@ export async function initSessionState(params) {
     const trimmedBodyLower = trimmedBody.toLowerCase();
     const strippedForResetLower = strippedForReset.toLowerCase();
     for (const trigger of resetTriggers) {
-        if (!trigger)
+        if (!trigger) {
             continue;
-        if (!resetAuthorized)
+        }
+        if (!resetAuthorized) {
             break;
+        }
         const triggerLower = trigger.toLowerCase();
         if (trimmedBodyLower === triggerLower || strippedForResetLower === triggerLower) {
             isNewSession = true;
@@ -169,13 +181,25 @@ export async function initSessionState(params) {
         isNewSession = true;
         systemSent = false;
         abortedLastRun = false;
+        // When a reset trigger (/new, /reset) starts a new session, carry over
+        // user-set behavior overrides (verbose, thinking, reasoning, ttsAuto)
+        // so the user doesn't have to re-enable them every time.
+        if (resetTriggered && entry) {
+            persistedThinking = entry.thinkingLevel;
+            persistedVerbose = entry.verboseLevel;
+            persistedReasoning = entry.reasoningLevel;
+            persistedTtsAuto = entry.ttsAuto;
+        }
     }
     const baseEntry = !isNewSession && freshEntry ? entry : undefined;
     // Track the originating channel/to for announce routing (subagent announce-back).
     const lastChannelRaw = ctx.OriginatingChannel || baseEntry?.lastChannel;
     const lastToRaw = ctx.OriginatingTo || ctx.To || baseEntry?.lastTo;
     const lastAccountIdRaw = ctx.AccountId || baseEntry?.lastAccountId;
-    const lastThreadIdRaw = ctx.MessageThreadId || baseEntry?.lastThreadId;
+    // Only fall back to persisted threadId for thread sessions.  Non-thread
+    // sessions (e.g. DM without topics) must not inherit a stale threadId from a
+    // previous interaction that happened inside a topic/thread.
+    const lastThreadIdRaw = ctx.MessageThreadId || (isThread ? baseEntry?.lastThreadId : undefined);
     const deliveryFields = normalizeSessionDeliveryFields({
         deliveryContext: {
             channel: lastChannelRaw,
@@ -242,13 +266,18 @@ export async function initSessionState(params) {
         parentSessionKey &&
         parentSessionKey !== sessionKey &&
         sessionStore[parentSessionKey]) {
+        console.warn(`[session-init] forking from parent session: parentKey=${parentSessionKey} → sessionKey=${sessionKey} ` +
+            `parentTokens=${sessionStore[parentSessionKey].totalTokens ?? "?"}`);
         const forked = forkSessionFromParent({
             parentEntry: sessionStore[parentSessionKey],
+            agentId,
+            sessionsDir: path.dirname(storePath),
         });
         if (forked) {
             sessionId = forked.sessionId;
             sessionEntry.sessionId = forked.sessionId;
             sessionEntry.sessionFile = forked.sessionFile;
+            console.warn(`[session-init] forked session created: file=${forked.sessionFile}`);
         }
     }
     if (!sessionEntry.sessionFile) {
@@ -258,30 +287,82 @@ export async function initSessionState(params) {
         sessionEntry.compactionCount = 0;
         sessionEntry.memoryFlushCompactionCount = undefined;
         sessionEntry.memoryFlushAt = undefined;
+        // Clear stale token metrics from previous session so /status doesn't
+        // display the old session's context usage after /new or /reset.
+        sessionEntry.totalTokens = undefined;
+        sessionEntry.inputTokens = undefined;
+        sessionEntry.outputTokens = undefined;
+        sessionEntry.contextTokens = undefined;
     }
     // Preserve per-session overrides while resetting compaction state on /new.
     sessionStore[sessionKey] = { ...sessionStore[sessionKey], ...sessionEntry };
     await updateSessionStore(storePath, (store) => {
         // Preserve per-session overrides while resetting compaction state on /new.
         store[sessionKey] = { ...store[sessionKey], ...sessionEntry };
+    }, {
+        activeSessionKey: sessionKey,
+        onWarn: (warning) => deliverSessionMaintenanceWarning({
+            cfg,
+            sessionKey,
+            entry: sessionEntry,
+            warning,
+        }),
     });
+    // Archive old transcript so it doesn't accumulate on disk (#14869).
+    if (previousSessionEntry?.sessionId) {
+        archiveSessionTranscripts({
+            sessionId: previousSessionEntry.sessionId,
+            storePath,
+            sessionFile: previousSessionEntry.sessionFile,
+            agentId,
+            reason: "reset",
+        });
+    }
     const sessionCtx = {
         ...ctx,
         // Keep BodyStripped aligned with Body (best default for agent prompts).
         // RawBody is reserved for command/directive parsing and may omit context.
-        BodyStripped: formatInboundBodyWithSenderMeta({
-            ctx,
-            body: normalizeInboundTextNewlines(bodyStripped ??
-                ctx.BodyForAgent ??
-                ctx.Body ??
-                ctx.CommandBody ??
-                ctx.RawBody ??
-                ctx.BodyForCommands ??
-                ""),
-        }),
+        BodyStripped: normalizeInboundTextNewlines(bodyStripped ??
+            ctx.BodyForAgent ??
+            ctx.Body ??
+            ctx.CommandBody ??
+            ctx.RawBody ??
+            ctx.BodyForCommands ??
+            ""),
         SessionId: sessionId,
         IsNewSession: isNewSession ? "true" : "false",
     };
+    // Run session plugin hooks (fire-and-forget)
+    const hookRunner = getGlobalHookRunner();
+    if (hookRunner && isNewSession) {
+        const effectiveSessionId = sessionId ?? "";
+        // If replacing an existing session, fire session_end for the old one
+        if (previousSessionEntry?.sessionId && previousSessionEntry.sessionId !== effectiveSessionId) {
+            if (hookRunner.hasHooks("session_end")) {
+                void hookRunner
+                    .runSessionEnd({
+                    sessionId: previousSessionEntry.sessionId,
+                    messageCount: 0,
+                }, {
+                    sessionId: previousSessionEntry.sessionId,
+                    agentId: resolveSessionAgentId({ sessionKey, config: cfg }),
+                })
+                    .catch(() => { });
+            }
+        }
+        // Fire session_start for the new session
+        if (hookRunner.hasHooks("session_start")) {
+            void hookRunner
+                .runSessionStart({
+                sessionId: effectiveSessionId,
+                resumedFrom: previousSessionEntry?.sessionId,
+            }, {
+                sessionId: effectiveSessionId,
+                agentId: resolveSessionAgentId({ sessionKey, config: cfg }),
+            })
+                .catch(() => { });
+        }
+    }
     return {
         sessionCtx,
         sessionEntry,

package/dist/auto-reply/reply/streaming-directives.js

@@ -3,11 +3,13 @@ import { parseInlineDirectives } from "../../utils/directive-tags.js";
 import { isSilentReplyText, SILENT_REPLY_TOKEN } from "../tokens.js";
 const splitTrailingDirective = (text) => {
     const openIndex = text.lastIndexOf("[[");
-    if (openIndex < 0)
+    if (openIndex < 0) {
         return { text, tail: "" };
+    }
     const closeIndex = text.indexOf("]]", openIndex + 2);
-    if (closeIndex >= 0)
+    if (closeIndex >= 0) {
         return { text, tail: "" };
+    }
     return {
         text: text.slice(0, openIndex),
         tail: text.slice(openIndex),
@@ -47,9 +49,11 @@ const hasRenderableContent = (parsed) => Boolean(parsed.text) ||
 export function createStreamingDirectiveAccumulator() {
     let pendingTail = "";
     let pendingReply = { sawCurrent: false, hasTag: false };
+    let activeReply = { sawCurrent: false, hasTag: false };
     const reset = () => {
         pendingTail = "";
         pendingReply = { sawCurrent: false, hasTag: false };
+        activeReply = { sawCurrent: false, hasTag: false };
     };
     const consume = (raw, options = {}) => {
         let combined = `${pendingTail}${raw ?? ""}`;
@@ -63,9 +67,9 @@ export function createStreamingDirectiveAccumulator() {
             return null;
         }
         const parsed = parseChunk(combined, { silentToken: options.silentToken });
-        const hasTag = pendingReply.hasTag || parsed.replyToTag;
-        const sawCurrent = pendingReply.sawCurrent || parsed.replyToCurrent;
-        const explicitId = parsed.replyToExplicitId ?? pendingReply.explicitId;
+        const hasTag = activeReply.hasTag || pendingReply.hasTag || parsed.replyToTag;
+        const sawCurrent = activeReply.sawCurrent || pendingReply.sawCurrent || parsed.replyToCurrent;
+        const explicitId = parsed.replyToExplicitId ?? pendingReply.explicitId ?? activeReply.explicitId;
         const combinedResult = {
             ...parsed,
             replyToId: explicitId,
@@ -82,6 +86,13 @@ export function createStreamingDirectiveAccumulator() {
             }
             return null;
         }
+        // Keep reply context sticky for the full assistant message so split/newline chunks
+        // stay on the same native reply target until reset() is called for the next message.
+        activeReply = {
+            explicitId,
+            sawCurrent,
+            hasTag,
+        };
         pendingReply = { sawCurrent: false, hasTag: false };
         return combinedResult;
     };

package/dist/auto-reply/status.js

@@ -5,13 +5,15 @@ import { resolveModelAuthMode } from "../agents/model-auth.js";
 import { resolveConfiguredModelRef } from "../agents/model-selection.js";
 import { resolveSandboxRuntimeStatus } from "../agents/sandbox.js";
 import { derivePromptTokens, normalizeUsage } from "../agents/usage.js";
-import { resolveMainSessionKey, resolveSessionFilePath, } from "../config/sessions.js";
-import { getTtsMaxLength, getTtsProvider, isSummarizationEnabled, resolveTtsAutoMode, resolveTtsConfig, resolveTtsPrefsPath, } from "../tts/tts.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";
+import { listPluginCommands } from "../plugins/commands.js";
+import { resolveAgentIdFromSessionKey } from "../routing/session-key.js";
+import { getTtsMaxLength, getTtsProvider, isSummarizationEnabled, resolveTtsAutoMode, resolveTtsConfig, resolveTtsPrefsPath, } from "../tts/tts.js";
 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 { listPluginCommands } from "../plugins/commands.js";
 export const formatTokenCount = formatTokenCountShared;
 function resolveRuntimeLabel(args) {
     const sessionKey = args.sessionKey?.trim();
@@ -21,19 +23,23 @@ function resolveRuntimeLabel(args) {
             sessionKey,
         });
         const sandboxMode = runtimeStatus.mode ?? "off";
-        if (sandboxMode === "off")
+        if (sandboxMode === "off") {
             return "direct";
+        }
         const runtime = runtimeStatus.sandboxed ? "docker" : sessionKey ? "direct" : "unknown";
         return `${runtime}/${sandboxMode}`;
     }
     const sandboxMode = args.agent?.sandbox?.mode ?? "off";
-    if (sandboxMode === "off")
+    if (sandboxMode === "off") {
         return "direct";
+    }
     const sandboxed = (() => {
-        if (!sessionKey)
+        if (!sessionKey) {
             return false;
-        if (sandboxMode === "all")
+        }
+        if (sandboxMode === "all") {
             return true;
+        }
         if (args.config) {
             return resolveSandboxRuntimeStatus({
                 cfg: args.config,
@@ -61,48 +67,47 @@ const formatTokens = (total, contextTokens) => {
     return `${totalLabel}/${ctxLabel}${pct !== null ? ` (${pct}%)` : ""}`;
 };
 export const formatContextUsageShort = (total, contextTokens) => `Context ${formatTokens(total, contextTokens ?? null)}`;
-const formatAge = (ms) => {
-    if (!ms || ms < 0)
-        return "unknown";
-    const minutes = Math.round(ms / 60_000);
-    if (minutes < 1)
-        return "just now";
-    if (minutes < 60)
-        return `${minutes}m ago`;
-    const hours = Math.round(minutes / 60);
-    if (hours < 48)
-        return `${hours}h ago`;
-    const days = Math.round(hours / 24);
-    return `${days}d ago`;
-};
 const formatQueueDetails = (queue) => {
-    if (!queue)
+    if (!queue) {
         return "";
+    }
     const depth = typeof queue.depth === "number" ? `depth ${queue.depth}` : null;
     if (!queue.showDetails) {
         return depth ? ` (${depth})` : "";
     }
     const detailParts = [];
-    if (depth)
+    if (depth) {
         detailParts.push(depth);
+    }
     if (typeof queue.debounceMs === "number") {
         const ms = Math.max(0, Math.round(queue.debounceMs));
         const label = ms >= 1000 ? `${ms % 1000 === 0 ? ms / 1000 : (ms / 1000).toFixed(1)}s` : `${ms}ms`;
         detailParts.push(`debounce ${label}`);
     }
-    if (typeof queue.cap === "number")
+    if (typeof queue.cap === "number") {
         detailParts.push(`cap ${queue.cap}`);
-    if (queue.dropPolicy)
+    }
+    if (queue.dropPolicy) {
         detailParts.push(`drop ${queue.dropPolicy}`);
+    }
     return detailParts.length ? ` (${detailParts.join(" · ")})` : "";
 };
-const readUsageFromSessionLog = (sessionId, sessionEntry) => {
+const readUsageFromSessionLog = (sessionId, sessionEntry, agentId, sessionKey, storePath) => {
     // Transcripts are stored at the session file path (fallback: ~/.poolbot/sessions/<SessionId>.jsonl)
-    if (!sessionId)
+    if (!sessionId) {
         return undefined;
-    const logPath = resolveSessionFilePath(sessionId, sessionEntry);
-    if (!fs.existsSync(logPath))
+    }
+    let logPath;
+    try {
+        const resolvedAgentId = agentId ?? (sessionKey ? resolveAgentIdFromSessionKey(sessionKey) : undefined);
+        logPath = resolveSessionFilePath(sessionId, sessionEntry, resolveSessionFilePathOptions({ agentId: resolvedAgentId, storePath }));
+    }
+    catch {
+        return undefined;
+    }
+    if (!fs.existsSync(logPath)) {
         return undefined;
+    }
     try {
         const lines = fs.readFileSync(logPath, "utf-8").split(/\n+/);
         let input = 0;
@@ -111,28 +116,32 @@ const readUsageFromSessionLog = (sessionId, sessionEntry) => {
         let model;
         let lastUsage;
         for (const line of lines) {
-            if (!line.trim())
+            if (!line.trim()) {
                 continue;
+            }
             try {
                 const parsed = JSON.parse(line);
                 const usageRaw = parsed.message?.usage ?? parsed.usage;
                 const usage = normalizeUsage(usageRaw);
-                if (usage)
+                if (usage) {
                     lastUsage = usage;
+                }
                 model = parsed.message?.model ?? parsed.model ?? model;
             }
             catch {
                 // ignore bad lines
             }
         }
-        if (!lastUsage)
+        if (!lastUsage) {
             return undefined;
+        }
         input = lastUsage.input ?? 0;
         output = lastUsage.output ?? 0;
         promptTokens = derivePromptTokens(lastUsage) ?? lastUsage.total ?? input + output;
         const total = lastUsage.total ?? promptTokens + output;
-        if (promptTokens === 0 && total === 0)
+        if (promptTokens === 0 && total === 0) {
             return undefined;
+        }
         return { input, output, promptTokens, total, model };
     }
     catch {
@@ -140,15 +149,17 @@ const readUsageFromSessionLog = (sessionId, sessionEntry) => {
     }
 };
 const formatUsagePair = (input, output) => {
-    if (input == null && output == null)
+    if (input == null && output == null) {
         return null;
+    }
     const inputLabel = typeof input === "number" ? formatTokenCount(input) : "?";
     const outputLabel = typeof output === "number" ? formatTokenCount(output) : "?";
     return `🧮 Tokens: ${inputLabel} in / ${outputLabel} out`;
 };
 const formatMediaUnderstandingLine = (decisions) => {
-    if (!decisions || decisions.length === 0)
+    if (!decisions || decisions.length === 0) {
         return null;
+    }
     const parts = decisions
         .map((decision) => {
         const count = decision.attachments.length;
@@ -179,15 +190,18 @@ const formatMediaUnderstandingLine = (decisions) => {
         return null;
     })
         .filter((part) => part != null);
-    if (parts.length === 0)
+    if (parts.length === 0) {
         return null;
-    if (parts.every((part) => part.endsWith(" none")))
+    }
+    if (parts.every((part) => part.endsWith(" none"))) {
         return null;
+    }
     return `📎 Media: ${parts.join(" · ")}`;
 };
 const formatVoiceModeLine = (config, sessionEntry) => {
-    if (!config)
+    if (!config) {
         return null;
+    }
     const ttsConfig = resolveTtsConfig(config);
     const prefsPath = resolveTtsPrefsPath(ttsConfig);
     const autoMode = resolveTtsAutoMode({
@@ -195,8 +209,9 @@ const formatVoiceModeLine = (config, sessionEntry) => {
         prefsPath,
         sessionAuto: sessionEntry?.ttsAuto,
     });
-    if (autoMode === "off")
+    if (autoMode === "off") {
         return null;
+    }
     const provider = getTtsProvider(ttsConfig, prefsPath);
     const maxLength = getTtsMaxLength(prefsPath);
     const summarize = isSummarizationEnabled(prefsPath) ? "on" : "off";
@@ -226,21 +241,24 @@ export function buildStatusMessage(args) {
     // Prefer prompt-size tokens from the session transcript when it looks larger
     // (cached prompt tokens are often missing from agent meta/store).
     if (args.includeTranscriptUsage) {
-        const logUsage = readUsageFromSessionLog(entry?.sessionId, entry);
+        const logUsage = readUsageFromSessionLog(entry?.sessionId, entry, args.agentId, args.sessionKey, args.sessionStorePath);
         if (logUsage) {
             const candidate = logUsage.promptTokens || logUsage.total;
             if (!totalTokens || totalTokens === 0 || candidate > totalTokens) {
                 totalTokens = candidate;
             }
-            if (!model)
+            if (!model) {
                 model = logUsage.model ?? model;
+            }
             if (!contextTokens && logUsage.model) {
                 contextTokens = lookupContextTokens(logUsage.model) ?? contextTokens;
             }
-            if (!inputTokens || inputTokens === 0)
+            if (!inputTokens || inputTokens === 0) {
                 inputTokens = logUsage.input;
-            if (!outputTokens || outputTokens === 0)
+            }
+            if (!outputTokens || outputTokens === 0) {
                 outputTokens = logUsage.output;
+            }
         }
     }
     const thinkLevel = args.resolvedThink ?? args.agent?.thinkingDefault ?? "off";
@@ -254,7 +272,7 @@ export function buildStatusMessage(args) {
     const updatedAt = entry?.updatedAt;
     const sessionLine = [
         `Session: ${args.sessionKey ?? "unknown"}`,
-        typeof updatedAt === "number" ? `updated ${formatAge(now - updatedAt)}` : "no activity",
+        typeof updatedAt === "number" ? `updated ${formatTimeAgo(now - updatedAt)}` : "no activity",
     ]
         .filter(Boolean)
         .join(" • ");
@@ -317,7 +335,7 @@ export function buildStatusMessage(args) {
     const authLabel = authLabelValue ? ` · 🔑 ${authLabelValue}` : "";
     const modelLine = `🧠 Model: ${modelLabel}${authLabel}`;
     const commit = resolveCommitHash();
-    const versionLine = `🦞 Poolbot ${VERSION}${commit ? ` (${commit})` : ""}`;
+    const versionLine = `🦞 Pool Bot ${VERSION}${commit ? ` (${commit})` : ""}`;
     const usagePair = formatUsagePair(inputTokens, outputTokens);
     const costLine = costLabel ? `💵 Cost: ${costLabel}` : null;
     const usageCostLine = usagePair && costLine ? `${usagePair} · ${costLine}` : (usagePair ?? costLine);
@@ -377,10 +395,12 @@ 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 (cfg?.commands?.config === true) {
         optionParts.push("/config");
-    if (cfg?.commands?.debug === true)
+    }
+    if (cfg?.commands?.debug === true) {
         optionParts.push("/debug");
+    }
     lines.push("Options");
     lines.push(`  ${optionParts.join("  |  ")}`);
     lines.push("");
@@ -405,8 +425,9 @@ function formatCommandEntry(command) {
         .filter((alias) => alias.toLowerCase() !== primary.toLowerCase())
         .filter((alias) => {
         const key = alias.toLowerCase();
-        if (seen.has(key))
+        if (seen.has(key)) {
             return false;
+        }
         seen.add(key);
         return true;
     });
@@ -419,8 +440,9 @@ function buildCommandItems(commands, pluginCommands) {
     const items = [];
     for (const category of CATEGORY_ORDER) {
         const categoryCommands = grouped.get(category) ?? [];
-        if (categoryCommands.length === 0)
+        if (categoryCommands.length === 0) {
             continue;
+        }
         const label = CATEGORY_LABELS[category];
         for (const command of categoryCommands) {
             items.push({ label, text: formatCommandEntry(command) });
@@ -440,8 +462,9 @@ function formatCommandList(items) {
     let currentLabel = null;
     for (const item of items) {
         if (item.label !== currentLabel) {
-            if (lines.length > 0)
+            if (lines.length > 0) {
                 lines.push("");
+            }
             lines.push(item.label);
             currentLabel = item.label;
         }

package/dist/browser/extension-relay.js

@@ -144,9 +144,9 @@ export async function ensureChromeExtensionRelayServer(opts) {
             case "Browser.getVersion":
                 return {
                     protocolVersion: "1.3",
-                    product: "Chrome/Poolbot-Extension-Relay",
+                    product: "Chrome/PoolBot-Extension-Relay",
                     revision: "0",
-                    userAgent: "Poolbot-Extension-Relay",
+                    userAgent: "PoolBot-Extension-Relay",
                     jsVersion: "V8",
                 };
             case "Browser.setDownloadBehavior":
@@ -240,7 +240,7 @@ export async function ensureChromeExtensionRelayServer(opts) {
         if ((path === "/json/version" || path === "/json/version/") &&
             (req.method === "GET" || req.method === "PUT")) {
             const payload = {
-                Browser: "Poolbot/extension-relay",
+                Browser: "PoolBot/extension-relay",
                 "Protocol-Version": "1.3",
             };
             // Only advertise the WS URL if a real extension is connected.

package/dist/browser/http-auth.js

@@ -39,7 +39,7 @@ export function isAuthorizedBrowserRequest(req, auth) {
         }
     }
     if (auth.password) {
-        const passwordHeader = firstHeaderValue(req.headers["x-openclaw-password"]).trim();
+        const passwordHeader = firstHeaderValue(req.headers["x-poolbot-password"]).trim();
         if (passwordHeader && safeEqualSecret(passwordHeader, auth.password)) {
             return true;
         }

package/dist/browser/paths.js

@@ -1,6 +1,6 @@
 import path from "node:path";
-import { resolvePreferredOpenClawTmpDir } from "../infra/tmp-poolbot-dir.js";
-export const DEFAULT_BROWSER_TMP_DIR = resolvePreferredOpenClawTmpDir();
+import { resolvePreferredPoolbotTmpDir } from "../infra/tmp-poolbot-dir.js";
+export const DEFAULT_BROWSER_TMP_DIR = resolvePreferredPoolbotTmpDir();
 export const DEFAULT_TRACE_DIR = DEFAULT_BROWSER_TMP_DIR;
 export const DEFAULT_DOWNLOAD_DIR = path.join(DEFAULT_BROWSER_TMP_DIR, "downloads");
 export const DEFAULT_UPLOAD_DIR = path.join(DEFAULT_BROWSER_TMP_DIR, "uploads");

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "2026.2.21",
-  "commit": "c1b8db5b38e189213061393716632d810d42bafd",
-  "builtAt": "2026-02-18T06:05:30.087Z"
+  "version": "2026.2.22",
+  "commit": "2f28abca3332ffa8582bc9169e87e707374b2c56",
+  "builtAt": "2026-02-18T13:03:00.077Z"
 }

package/dist/channels/allowlist-match.js

@@ -1,3 +1,23 @@
 export function formatAllowlistMatchMeta(match) {
     return `matchKey=${match?.matchKey ?? "none"} matchSource=${match?.matchSource ?? "none"}`;
 }
+export function resolveAllowlistMatchSimple(params) {
+    const allowFrom = params.allowFrom
+        .map((entry) => String(entry).trim().toLowerCase())
+        .filter(Boolean);
+    if (allowFrom.length === 0) {
+        return { allowed: false };
+    }
+    if (allowFrom.includes("*")) {
+        return { allowed: true, matchKey: "*", matchSource: "wildcard" };
+    }
+    const senderId = params.senderId.toLowerCase();
+    if (allowFrom.includes(senderId)) {
+        return { allowed: true, matchKey: senderId, matchSource: "id" };
+    }
+    const senderName = params.senderName?.toLowerCase();
+    if (senderName && allowFrom.includes(senderName)) {
+        return { allowed: true, matchKey: senderName, matchSource: "name" };
+    }
+    return { allowed: false };
+}