@poolzin/pool-bot 2026.2.25 → 2026.2.26

package/dist/acp/event-mapper.js

@@ -1,21 +1,76 @@
-export function extractTextFromPrompt(prompt) {
+const INLINE_CONTROL_ESCAPE_MAP = {
+    "\0": "\\0",
+    "\r": "\\r",
+    "\n": "\\n",
+    "\t": "\\t",
+    "\v": "\\v",
+    "\f": "\\f",
+    "\u2028": "\\u2028",
+    "\u2029": "\\u2029",
+};
+function escapeInlineControlChars(value) {
+    let escaped = "";
+    for (const char of value) {
+        const codePoint = char.codePointAt(0);
+        if (codePoint === undefined) {
+            escaped += char;
+            continue;
+        }
+        const isInlineControl = codePoint <= 0x1f ||
+            (codePoint >= 0x7f && codePoint <= 0x9f) ||
+            codePoint === 0x2028 ||
+            codePoint === 0x2029;
+        if (!isInlineControl) {
+            escaped += char;
+            continue;
+        }
+        const mapped = INLINE_CONTROL_ESCAPE_MAP[char];
+        if (mapped) {
+            escaped += mapped;
+            continue;
+        }
+        // Keep escaped control bytes readable and stable in logs/prompts.
+        escaped +=
+            codePoint <= 0xff
+                ? `\\x${codePoint.toString(16).padStart(2, "0")}`
+                : `\\u${codePoint.toString(16).padStart(4, "0")}`;
+    }
+    return escaped;
+}
+function escapeResourceTitle(value) {
+    // Keep title content, but escape characters that can break the resource-link annotation shape.
+    return escapeInlineControlChars(value).replace(/[()[\]]/g, (char) => `\\${char}`);
+}
+export function extractTextFromPrompt(prompt, maxBytes) {
     const parts = [];
+    // Track accumulated byte count per block to catch oversized prompts before full concatenation
+    let totalBytes = 0;
     for (const block of prompt) {
+        let blockText;
         if (block.type === "text") {
-            parts.push(block.text);
-            continue;
+            blockText = block.text;
         }
-        if (block.type === "resource") {
+        else if (block.type === "resource") {
             const resource = block.resource;
-            if (resource?.text)
-                parts.push(resource.text);
-            continue;
+            if (resource?.text) {
+                blockText = resource.text;
+            }
         }
-        if (block.type === "resource_link") {
-            const title = block.title ? ` (${block.title})` : "";
-            const uri = block.uri ?? "";
-            const line = uri ? `[Resource link${title}] ${uri}` : `[Resource link${title}]`;
-            parts.push(line);
+        else if (block.type === "resource_link") {
+            const title = block.title ? ` (${escapeResourceTitle(block.title)})` : "";
+            const uri = block.uri ? escapeInlineControlChars(block.uri) : "";
+            blockText = uri ? `[Resource link${title}] ${uri}` : `[Resource link${title}]`;
+        }
+        if (blockText !== undefined) {
+            // Guard: reject before allocating the full concatenated string
+            if (maxBytes !== undefined) {
+                const separatorBytes = parts.length > 0 ? 1 : 0; // "\n" added by join() between blocks
+                totalBytes += separatorBytes + Buffer.byteLength(blockText, "utf-8");
+                if (totalBytes > maxBytes) {
+                    throw new Error(`Prompt exceeds maximum allowed size of ${maxBytes} bytes`);
+                }
+            }
+            parts.push(blockText);
         }
     }
     return parts.join("\n");
@@ -23,11 +78,13 @@ export function extractTextFromPrompt(prompt) {
 export function extractAttachmentsFromPrompt(prompt) {
     const attachments = [];
     for (const block of prompt) {
-        if (block.type !== "image")
+        if (block.type !== "image") {
             continue;
+        }
         const image = block;
-        if (!image.data || !image.mimeType)
+        if (!image.data || !image.mimeType) {
             continue;
+        }
         attachments.push({
             type: "image",
             mimeType: image.mimeType,
@@ -38,8 +95,9 @@ export function extractAttachmentsFromPrompt(prompt) {
 }
 export function formatToolTitle(name, args) {
     const base = name ?? "tool";
-    if (!args || Object.keys(args).length === 0)
+    if (!args || Object.keys(args).length === 0) {
         return base;
+    }
     const parts = Object.entries(args).map(([key, value]) => {
         const raw = typeof value === "string" ? value : JSON.stringify(value);
         const safe = raw.length > 100 ? `${raw.slice(0, 100)}...` : raw;
@@ -48,23 +106,30 @@ export function formatToolTitle(name, args) {
     return `${base}: ${parts.join(", ")}`;
 }
 export function inferToolKind(name) {
-    if (!name)
+    if (!name) {
         return "other";
+    }
     const normalized = name.toLowerCase();
-    if (normalized.includes("read"))
+    if (normalized.includes("read")) {
         return "read";
-    if (normalized.includes("write") || normalized.includes("edit"))
+    }
+    if (normalized.includes("write") || normalized.includes("edit")) {
         return "edit";
-    if (normalized.includes("delete") || normalized.includes("remove"))
+    }
+    if (normalized.includes("delete") || normalized.includes("remove")) {
         return "delete";
-    if (normalized.includes("move") || normalized.includes("rename"))
+    }
+    if (normalized.includes("move") || normalized.includes("rename")) {
         return "move";
-    if (normalized.includes("search") || normalized.includes("find"))
+    }
+    if (normalized.includes("search") || normalized.includes("find")) {
         return "search";
+    }
     if (normalized.includes("exec") || normalized.includes("run") || normalized.includes("bash")) {
         return "execute";
     }
-    if (normalized.includes("fetch") || normalized.includes("http"))
+    if (normalized.includes("fetch") || normalized.includes("http")) {
         return "fetch";
+    }
     return "other";
 }

package/dist/acp/meta.js

@@ -1,30 +1,36 @@
 export function readString(meta, keys) {
-    if (!meta)
+    if (!meta) {
         return undefined;
+    }
     for (const key of keys) {
         const value = meta[key];
-        if (typeof value === "string" && value.trim())
+        if (typeof value === "string" && value.trim()) {
             return value.trim();
+        }
     }
     return undefined;
 }
 export function readBool(meta, keys) {
-    if (!meta)
+    if (!meta) {
         return undefined;
+    }
     for (const key of keys) {
         const value = meta[key];
-        if (typeof value === "boolean")
+        if (typeof value === "boolean") {
             return value;
+        }
     }
     return undefined;
 }
 export function readNumber(meta, keys) {
-    if (!meta)
+    if (!meta) {
         return undefined;
+    }
     for (const key of keys) {
         const value = meta[key];
-        if (typeof value === "number" && Number.isFinite(value))
+        if (typeof value === "number" && Number.isFinite(value)) {
             return value;
+        }
     }
     return undefined;
 }

package/dist/agents/agent-paths.js

@@ -3,21 +3,20 @@ import { resolveStateDir } from "../config/paths.js";
 import { DEFAULT_AGENT_ID } from "../routing/session-key.js";
 import { resolveUserPath } from "../utils.js";
 export function resolvePoolbotAgentDir() {
-    const override = process.env.POOLBOT_AGENT_DIR?.trim() ||
-        process.env.CLAWDBOT_AGENT_DIR?.trim() ||
-        process.env.PI_CODING_AGENT_DIR?.trim();
-    if (override)
+    const override = process.env.POOLBOT_AGENT_DIR?.trim() || process.env.PI_CODING_AGENT_DIR?.trim();
+    if (override) {
         return resolveUserPath(override);
+    }
     const defaultAgentDir = path.join(resolveStateDir(), "agents", DEFAULT_AGENT_ID, "agent");
     return resolveUserPath(defaultAgentDir);
 }
-export function ensurePoolbotAgentEnv() {
+export function ensurePoolBotAgentEnv() {
     const dir = resolvePoolbotAgentDir();
-    if (!process.env.POOLBOT_AGENT_DIR)
+    if (!process.env.POOLBOT_AGENT_DIR) {
         process.env.POOLBOT_AGENT_DIR = dir;
-    if (!process.env.CLAWDBOT_AGENT_DIR)
-        process.env.CLAWDBOT_AGENT_DIR = dir;
-    if (!process.env.PI_CODING_AGENT_DIR)
+    }
+    if (!process.env.PI_CODING_AGENT_DIR) {
         process.env.PI_CODING_AGENT_DIR = dir;
+    }
     return dir;
 }

package/dist/agents/agent-scope.js

@@ -4,17 +4,19 @@ import { resolveStateDir } from "../config/paths.js";
 import { DEFAULT_AGENT_ID, normalizeAgentId, parseAgentSessionKey, } from "../routing/session-key.js";
 import { normalizeSkillFilter } from "./skills/filter.js";
 import { resolveUserPath } from "../utils.js";
+import { createSubsystemLogger } from "../logging/subsystem.js";
 import { DEFAULT_AGENT_WORKSPACE_DIR } from "./workspace.js";
+const log = createSubsystemLogger("agent-scope");
 export { resolveAgentIdFromSessionKey } from "../routing/session-key.js";
 let defaultAgentWarned = false;
-function listAgents(cfg) {
+export function listAgentEntries(cfg) {
     const list = cfg.agents?.list;
     if (!Array.isArray(list))
         return [];
     return list.filter((entry) => Boolean(entry && typeof entry === "object"));
 }
 export function listAgentIds(cfg) {
-    const agents = listAgents(cfg);
+    const agents = listAgentEntries(cfg);
     if (agents.length === 0)
         return [DEFAULT_AGENT_ID];
     const seen = new Set();
@@ -29,13 +31,13 @@ export function listAgentIds(cfg) {
     return ids.length > 0 ? ids : [DEFAULT_AGENT_ID];
 }
 export function resolveDefaultAgentId(cfg) {
-    const agents = listAgents(cfg);
+    const agents = listAgentEntries(cfg);
     if (agents.length === 0)
         return DEFAULT_AGENT_ID;
     const defaults = agents.filter((agent) => agent?.default);
     if (defaults.length > 1 && !defaultAgentWarned) {
         defaultAgentWarned = true;
-        console.warn("Multiple agents marked default=true; using the first entry as default.");
+        log.warn("Multiple agents marked default=true; using the first entry as default.");
     }
     const chosen = (defaults[0] ?? agents[0])?.id?.trim();
     return normalizeAgentId(chosen || DEFAULT_AGENT_ID);
@@ -53,7 +55,7 @@ export function resolveSessionAgentId(params) {
 }
 function resolveAgentEntry(cfg, agentId) {
     const id = normalizeAgentId(agentId);
-    return listAgents(cfg).find((entry) => normalizeAgentId(entry.id) === id);
+    return listAgentEntries(cfg).find((entry) => normalizeAgentId(entry.id) === id);
 }
 export function resolveAgentConfig(cfg, agentId) {
     const id = normalizeAgentId(agentId);

package/dist/agents/auth-profiles/oauth.js

@@ -1,12 +1,37 @@
-import { getOAuthApiKey } from "@mariozechner/pi-ai";
-import lockfile from "proper-lockfile";
-import { refreshChutesTokens } from "../chutes-oauth.js";
+import { getOAuthApiKey, getOAuthProviders, } from "@mariozechner/pi-ai";
+import { withFileLock } from "../../infra/file-lock.js";
 import { refreshQwenPortalCredentials } from "../../providers/qwen-portal-oauth.js";
+import { refreshChutesTokens } from "../chutes-oauth.js";
 import { AUTH_STORE_LOCK_OPTIONS, log } from "./constants.js";
 import { formatAuthDoctorHint } from "./doctor.js";
 import { ensureAuthStoreFile, resolveAuthStorePath } from "./paths.js";
 import { suggestOAuthProfileIdForLegacyDefault } from "./repair.js";
 import { ensureAuthProfileStore, saveAuthProfileStore } from "./store.js";
+const OAUTH_PROVIDER_IDS = new Set(getOAuthProviders().map((provider) => provider.id));
+const isOAuthProvider = (provider) => OAUTH_PROVIDER_IDS.has(provider);
+const resolveOAuthProvider = (provider) => isOAuthProvider(provider) ? provider : null;
+/** Bearer-token auth modes that are interchangeable (oauth tokens and raw tokens). */
+const BEARER_AUTH_MODES = new Set(["oauth", "token"]);
+const isCompatibleModeType = (mode, type) => {
+    if (!mode || !type) {
+        return false;
+    }
+    if (mode === type) {
+        return true;
+    }
+    // Both token and oauth represent bearer-token auth paths — allow bidirectional compat.
+    return BEARER_AUTH_MODES.has(mode) && BEARER_AUTH_MODES.has(type);
+};
+function isProfileConfigCompatible(params) {
+    const profileConfig = params.cfg?.auth?.profiles?.[params.profileId];
+    if (profileConfig && profileConfig.provider !== params.provider) {
+        return false;
+    }
+    if (profileConfig && !isCompatibleModeType(profileConfig.mode, params.mode)) {
+        return false;
+    }
+    return true;
+}
 function buildOAuthApiKey(provider, credentials) {
     const needsProjectId = provider === "google-gemini-cli" || provider === "google-antigravity";
     return needsProjectId
@@ -16,18 +41,62 @@ function buildOAuthApiKey(provider, credentials) {
         })
         : credentials.access;
 }
+function buildApiKeyProfileResult(params) {
+    return {
+        apiKey: params.apiKey,
+        provider: params.provider,
+        email: params.email,
+    };
+}
+function buildOAuthProfileResult(params) {
+    return buildApiKeyProfileResult({
+        apiKey: buildOAuthApiKey(params.provider, params.credentials),
+        provider: params.provider,
+        email: params.email,
+    });
+}
+function isExpiredCredential(expires) {
+    return (typeof expires === "number" && Number.isFinite(expires) && expires > 0 && Date.now() >= expires);
+}
+function adoptNewerMainOAuthCredential(params) {
+    if (!params.agentDir) {
+        return null;
+    }
+    try {
+        const mainStore = ensureAuthProfileStore(undefined);
+        const mainCred = mainStore.profiles[params.profileId];
+        if (mainCred?.type === "oauth" &&
+            mainCred.provider === params.cred.provider &&
+            Number.isFinite(mainCred.expires) &&
+            (!Number.isFinite(params.cred.expires) || mainCred.expires > params.cred.expires)) {
+            params.store.profiles[params.profileId] = { ...mainCred };
+            saveAuthProfileStore(params.store, params.agentDir);
+            log.info("adopted newer OAuth credentials from main agent", {
+                profileId: params.profileId,
+                agentDir: params.agentDir,
+                expires: new Date(mainCred.expires).toISOString(),
+            });
+            return mainCred;
+        }
+    }
+    catch (err) {
+        // Best-effort: don't crash if main agent store is missing or unreadable.
+        log.debug("adoptNewerMainOAuthCredential failed", {
+            profileId: params.profileId,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+    return null;
+}
 async function refreshOAuthTokenWithLock(params) {
     const authPath = resolveAuthStorePath(params.agentDir);
     ensureAuthStoreFile(authPath);
-    let release;
-    try {
-        release = await lockfile.lock(authPath, {
-            ...AUTH_STORE_LOCK_OPTIONS,
-        });
+    return await withFileLock(authPath, AUTH_STORE_LOCK_OPTIONS, async () => {
         const store = ensureAuthProfileStore(params.agentDir);
         const cred = store.profiles[params.profileId];
-        if (!cred || cred.type !== "oauth")
+        if (!cred || cred.type !== "oauth") {
             return null;
+        }
         if (Date.now() < cred.expires) {
             return {
                 apiKey: buildOAuthApiKey(cred.provider, cred),
@@ -49,9 +118,16 @@ async function refreshOAuthTokenWithLock(params) {
                     const newCredentials = await refreshQwenPortalCredentials(cred);
                     return { apiKey: newCredentials.access, newCredentials };
                 })()
-                : await getOAuthApiKey(cred.provider, oauthCreds);
-        if (!result)
+                : await (async () => {
+                    const oauthProvider = resolveOAuthProvider(cred.provider);
+                    if (!oauthProvider) {
+                        return null;
+                    }
+                    return await getOAuthApiKey(oauthProvider, oauthCreds);
+                })();
+        if (!result) {
             return null;
+        }
         store.profiles[params.profileId] = {
             ...cred,
             ...result.newCredentials,
@@ -59,104 +135,111 @@ async function refreshOAuthTokenWithLock(params) {
         };
         saveAuthProfileStore(store, params.agentDir);
         return result;
-    }
-    finally {
-        if (release) {
-            try {
-                await release();
-            }
-            catch {
-                // ignore unlock errors
-            }
-        }
-    }
+    });
 }
 async function tryResolveOAuthProfile(params) {
     const { cfg, store, profileId } = params;
     const cred = store.profiles[profileId];
-    if (!cred || cred.type !== "oauth")
-        return null;
-    const profileConfig = cfg?.auth?.profiles?.[profileId];
-    if (profileConfig && profileConfig.provider !== cred.provider)
+    if (!cred || cred.type !== "oauth") {
         return null;
-    if (profileConfig && profileConfig.mode !== cred.type)
+    }
+    if (!isProfileConfigCompatible({
+        cfg,
+        profileId,
+        provider: cred.provider,
+        mode: cred.type,
+    })) {
         return null;
+    }
     if (Date.now() < cred.expires) {
-        return {
-            apiKey: buildOAuthApiKey(cred.provider, cred),
+        return buildOAuthProfileResult({
             provider: cred.provider,
+            credentials: cred,
             email: cred.email,
-        };
+        });
     }
     const refreshed = await refreshOAuthTokenWithLock({
         profileId,
         agentDir: params.agentDir,
     });
-    if (!refreshed)
+    if (!refreshed) {
         return null;
-    return {
+    }
+    return buildApiKeyProfileResult({
         apiKey: refreshed.apiKey,
         provider: cred.provider,
         email: cred.email,
-    };
+    });
 }
 export async function resolveApiKeyForProfile(params) {
     const { cfg, store, profileId } = params;
     const cred = store.profiles[profileId];
-    if (!cred)
-        return null;
-    const profileConfig = cfg?.auth?.profiles?.[profileId];
-    if (profileConfig && profileConfig.provider !== cred.provider)
+    if (!cred) {
         return null;
-    if (profileConfig && profileConfig.mode !== cred.type) {
+    }
+    if (!isProfileConfigCompatible({
+        cfg,
+        profileId,
+        provider: cred.provider,
+        mode: cred.type,
         // Compatibility: treat "oauth" config as compatible with stored token profiles.
-        if (!(profileConfig.mode === "oauth" && cred.type === "token"))
-            return null;
+        allowOAuthTokenCompatibility: true,
+    })) {
+        return null;
     }
     if (cred.type === "api_key") {
-        return { apiKey: cred.key, provider: cred.provider, email: cred.email };
+        const key = cred.key?.trim();
+        if (!key) {
+            return null;
+        }
+        return buildApiKeyProfileResult({ apiKey: key, provider: cred.provider, email: cred.email });
     }
     if (cred.type === "token") {
         const token = cred.token?.trim();
-        if (!token)
+        if (!token) {
             return null;
-        if (typeof cred.expires === "number" &&
-            Number.isFinite(cred.expires) &&
-            cred.expires > 0 &&
-            Date.now() >= cred.expires) {
+        }
+        if (isExpiredCredential(cred.expires)) {
             return null;
         }
-        return { apiKey: token, provider: cred.provider, email: cred.email };
+        return buildApiKeyProfileResult({ apiKey: token, provider: cred.provider, email: cred.email });
     }
-    if (Date.now() < cred.expires) {
-        return {
-            apiKey: buildOAuthApiKey(cred.provider, cred),
-            provider: cred.provider,
-            email: cred.email,
-        };
+    const oauthCred = adoptNewerMainOAuthCredential({
+        store,
+        profileId,
+        agentDir: params.agentDir,
+        cred,
+    }) ?? cred;
+    if (Date.now() < oauthCred.expires) {
+        return buildOAuthProfileResult({
+            provider: oauthCred.provider,
+            credentials: oauthCred,
+            email: oauthCred.email,
+        });
     }
     try {
         const result = await refreshOAuthTokenWithLock({
             profileId,
             agentDir: params.agentDir,
         });
-        if (!result)
+        if (!result) {
             return null;
-        return {
+        }
+        return buildApiKeyProfileResult({
             apiKey: result.apiKey,
             provider: cred.provider,
             email: cred.email,
-        };
+        });
     }
     catch (error) {
         const refreshedStore = ensureAuthProfileStore(params.agentDir);
         const refreshed = refreshedStore.profiles[profileId];
         if (refreshed?.type === "oauth" && Date.now() < refreshed.expires) {
-            return {
-                apiKey: buildOAuthApiKey(refreshed.provider, refreshed),
+            return buildOAuthProfileResult({
                 provider: refreshed.provider,
+                credentials: refreshed,
                 email: refreshed.email ?? cred.email,
-            };
+            });
         }
         const fallbackProfileId = suggestOAuthProfileIdForLegacyDefault({
             cfg,
@@ -172,8 +255,9 @@ export async function resolveApiKeyForProfile(params) {
                     profileId: fallbackProfileId,
                     agentDir: params.agentDir,
                 });
-                if (fallbackResolved)
+                if (fallbackResolved) {
                     return fallbackResolved;
+                }
             }
             catch {
                 // keep original error
@@ -193,11 +277,11 @@ export async function resolveApiKeyForProfile(params) {
                         agentDir: params.agentDir,
                         expires: new Date(mainCred.expires).toISOString(),
                     });
-                    return {
-                        apiKey: buildOAuthApiKey(mainCred.provider, mainCred),
+                    return buildOAuthProfileResult({
                         provider: mainCred.provider,
+                        credentials: mainCred,
                         email: mainCred.email,
-                    };
+                    });
                 }
             }
             catch {
@@ -213,6 +297,6 @@ export async function resolveApiKeyForProfile(params) {
         });
         throw new Error(`OAuth token refresh failed for ${cred.provider}: ${message}. ` +
             "Please try again or re-authenticate." +
-            (hint ? `\n\n${hint}` : ""));
+            (hint ? `\n\n${hint}` : ""), { cause: error });
     }
 }

package/dist/agents/auth-profiles/session-override.js

@@ -1,10 +1,11 @@
 import { updateSessionStore } from "../../config/sessions.js";
-import { normalizeProviderId } from "../model-selection.js";
 import { ensureAuthProfileStore, isProfileInCooldown, resolveAuthProfileOrder, } from "../auth-profiles.js";
+import { normalizeProviderId } from "../model-selection.js";
 function isProfileForProvider(params) {
     const entry = params.store.profiles[params.profileId];
-    if (!entry?.provider)
+    if (!entry?.provider) {
         return false;
+    }
     return normalizeProviderId(entry.provider) === normalizeProviderId(params.provider);
 }
 export async function clearSessionAuthProfileOverride(params) {
@@ -22,8 +23,9 @@ export async function clearSessionAuthProfileOverride(params) {
 }
 export async function resolveSessionAuthProfileOverride(params) {
     const { cfg, provider, agentDir, sessionEntry, sessionStore, sessionKey, storePath, isNewSession, } = params;
-    if (!sessionEntry || !sessionStore || !sessionKey)
+    if (!sessionEntry || !sessionStore || !sessionKey) {
         return sessionEntry?.authProfileOverride;
+    }
     const store = ensureAuthProfileStore(agentDir, { allowKeychainPrompt: false });
     const order = resolveAuthProfileOrder({ cfg, store, provider });
     let current = sessionEntry.authProfileOverride?.trim();
@@ -39,17 +41,20 @@ export async function resolveSessionAuthProfileOverride(params) {
         await clearSessionAuthProfileOverride({ sessionEntry, sessionStore, sessionKey, storePath });
         current = undefined;
     }
-    if (order.length === 0)
+    if (order.length === 0) {
         return undefined;
+    }
     const pickFirstAvailable = () => order.find((profileId) => !isProfileInCooldown(store, profileId)) ?? order[0];
     const pickNextAvailable = (active) => {
         const startIndex = order.indexOf(active);
-        if (startIndex < 0)
+        if (startIndex < 0) {
             return pickFirstAvailable();
+        }
         for (let offset = 1; offset <= order.length; offset += 1) {
             const candidate = order[(startIndex + offset) % order.length];
-            if (!isProfileInCooldown(store, candidate))
+            if (!isProfileInCooldown(store, candidate)) {
                 return candidate;
+            }
         }
         return order[startIndex] ?? order[0];
     };
@@ -76,8 +81,9 @@ export async function resolveSessionAuthProfileOverride(params) {
     else if (!current || isProfileInCooldown(store, current)) {
         next = pickFirstAvailable();
     }
-    if (!next)
+    if (!next) {
         return current;
+    }
     const shouldPersist = next !== sessionEntry.authProfileOverride ||
         sessionEntry.authProfileOverrideSource !== "auto" ||
         sessionEntry.authProfileOverrideCompactionCount !== compactionCount;