@poolzin/pool-bot 2026.2.25 → 2026.2.26

package/dist/commands/status-all/format.js

@@ -30,6 +30,7 @@ export function formatGatewayAuthUsed(auth) {
         return "password";
     return "none";
 }
+export { formatTimeAgo } from "../../infra/format-time/format-relative.js";
 export function redactSecrets(text) {
     if (!text)
         return text;

package/dist/commands/status.gateway-probe.js

@@ -1,3 +1,4 @@
+export { pickGatewaySelfPresence } from "./gateway-presence.js";
 export function resolveGatewayProbeAuth(cfg) {
     const isRemoteMode = cfg.gateway?.mode === "remote";
     const remote = isRemoteMode ? cfg.gateway?.remote : undefined;
@@ -8,10 +9,8 @@ export function resolveGatewayProbeAuth(cfg) {
             ? remote.token.trim()
             : undefined
         : process.env.POOLBOT_GATEWAY_TOKEN?.trim() ||
-            process.env.CLAWDBOT_GATEWAY_TOKEN?.trim() ||
             (typeof authToken === "string" && authToken.trim().length > 0 ? authToken.trim() : undefined);
     const password = process.env.POOLBOT_GATEWAY_PASSWORD?.trim() ||
-        process.env.CLAWDBOT_GATEWAY_PASSWORD?.trim() ||
         (isRemoteMode
             ? typeof remote?.password === "string" && remote.password.trim().length > 0
                 ? remote.password.trim()
@@ -21,17 +20,3 @@ export function resolveGatewayProbeAuth(cfg) {
                 : undefined);
     return { token, password };
 }
-export function pickGatewaySelfPresence(presence) {
-    if (!Array.isArray(presence))
-        return null;
-    const entries = presence;
-    const self = entries.find((e) => e.mode === "gateway" && e.reason === "self") ?? null;
-    if (!self)
-        return null;
-    return {
-        host: typeof self.host === "string" ? self.host : undefined,
-        ip: typeof self.ip === "string" ? self.ip : undefined,
-        version: typeof self.version === "string" ? self.version : undefined,
-        platform: typeof self.platform === "string" ? self.platform : undefined,
-    };
-}

package/dist/commands/systemd-linger.js

@@ -1,10 +1,12 @@
 import { enableSystemdUserLinger, isSystemdUserServiceAvailable, readSystemdUserLingerStatus, } from "../daemon/systemd.js";
 import { note } from "../terminal/note.js";
 export async function ensureSystemdUserLingerInteractive(params) {
-    if (process.platform !== "linux")
+    if (process.platform !== "linux") {
         return;
-    if (params.prompt === false)
+    }
+    if (params.prompt === false) {
         return;
+    }
     const env = params.env ?? process.env;
     const prompter = params.prompter ?? { note };
     const title = params.title ?? "Systemd";
@@ -17,8 +19,9 @@ export async function ensureSystemdUserLingerInteractive(params) {
         await prompter.note("Unable to read loginctl linger status. Ensure systemd + loginctl are available.", title);
         return;
     }
-    if (status.linger === "yes")
+    if (status.linger === "yes") {
         return;
+    }
     const reason = params.reason ??
         "Systemd user services stop when you log out or go idle, which kills the Gateway.";
     const actionNote = params.requireConfirm
@@ -56,14 +59,17 @@ export async function ensureSystemdUserLingerInteractive(params) {
     await prompter.note(`Run manually: sudo loginctl enable-linger ${status.user}`, title);
 }
 export async function ensureSystemdUserLingerNonInteractive(params) {
-    if (process.platform !== "linux")
+    if (process.platform !== "linux") {
         return;
+    }
     const env = params.env ?? process.env;
-    if (!(await isSystemdUserServiceAvailable()))
+    if (!(await isSystemdUserServiceAvailable())) {
         return;
+    }
     const status = await readSystemdUserLingerStatus(env);
-    if (!status || status.linger === "yes")
+    if (!status || status.linger === "yes") {
         return;
+    }
     const result = await enableSystemdUserLinger({
         env,
         user: status.user,

package/dist/config/agent-limits.js

@@ -1,5 +1,7 @@
 export const DEFAULT_AGENT_MAX_CONCURRENT = 4;
 export const DEFAULT_SUBAGENT_MAX_CONCURRENT = 8;
+// Keep depth-1 subagents as leaves unless config explicitly opts into nesting.
+export const DEFAULT_SUBAGENT_MAX_SPAWN_DEPTH = 1;
 export function resolveAgentMaxConcurrent(cfg) {
     const raw = cfg?.agents?.defaults?.maxConcurrent;
     if (typeof raw === "number" && Number.isFinite(raw)) {

package/dist/config/commands.js

@@ -1,41 +1,55 @@
 import { normalizeChannelId } from "../channels/plugins/index.js";
+import { isPlainObject } from "../infra/plain-object.js";
 function resolveAutoDefault(providerId) {
     const id = normalizeChannelId(providerId);
-    if (!id)
+    if (!id) {
         return false;
-    if (id === "discord" || id === "telegram")
+    }
+    if (id === "discord" || id === "telegram") {
         return true;
-    if (id === "slack")
+    }
+    if (id === "slack") {
         return false;
+    }
     return false;
 }
 export function resolveNativeSkillsEnabled(params) {
-    const { providerId, providerSetting, globalSetting } = params;
-    const setting = providerSetting === undefined ? globalSetting : providerSetting;
-    if (setting === true)
-        return true;
-    if (setting === false)
-        return false;
-    return resolveAutoDefault(providerId);
+    return resolveNativeCommandSetting(params);
 }
 export function resolveNativeCommandsEnabled(params) {
+    return resolveNativeCommandSetting(params);
+}
+function resolveNativeCommandSetting(params) {
     const { providerId, providerSetting, globalSetting } = params;
     const setting = providerSetting === undefined ? globalSetting : providerSetting;
-    if (setting === true)
+    if (setting === true) {
         return true;
-    if (setting === false)
+    }
+    if (setting === false) {
         return false;
-    // auto or undefined -> heuristic
+    }
     return resolveAutoDefault(providerId);
 }
 export function isNativeCommandsExplicitlyDisabled(params) {
     const { providerSetting, globalSetting } = params;
-    if (providerSetting === false)
+    if (providerSetting === false) {
         return true;
-    if (providerSetting === undefined)
+    }
+    if (providerSetting === undefined) {
         return globalSetting === false;
+    }
     return false;
 }
+function getOwnCommandFlagValue(config, key) {
+    const { commands } = config ?? {};
+    if (!isPlainObject(commands) || !Object.hasOwn(commands, key)) {
+        return undefined;
+    }
+    return commands[key];
+}
+export function isCommandFlagEnabled(config, key) {
+    return getOwnCommandFlagValue(config, key) === true;
+}
 export function isRestartEnabled(config) {
-    return config?.commands?.restart !== false;
+    return getOwnCommandFlagValue(config, "restart") !== false;
 }

package/dist/config/config-paths.js

@@ -1,4 +1,5 @@
-const BLOCKED_KEYS = new Set(["__proto__", "prototype", "constructor"]);
+import { isPlainObject } from "../utils.js";
+import { isBlockedObjectKey } from "./prototype-keys.js";
 export function parseConfigPath(raw) {
     const trimmed = raw.trim();
     if (!trimmed) {
@@ -14,7 +15,7 @@ export function parseConfigPath(raw) {
             error: "Invalid path. Use dot notation (e.g. foo.bar).",
         };
     }
-    if (parts.some((part) => BLOCKED_KEYS.has(part))) {
+    if (parts.some((part) => isBlockedObjectKey(part))) {
         return { ok: false, error: "Invalid path segment." };
     }
     return { ok: true, path: parts };
@@ -37,14 +38,16 @@ export function unsetConfigValueAtPath(root, path) {
     for (let idx = 0; idx < path.length - 1; idx += 1) {
         const key = path[idx];
         const next = cursor[key];
-        if (!isPlainObject(next))
+        if (!isPlainObject(next)) {
             return false;
+        }
         stack.push({ node: cursor, key });
         cursor = next;
     }
     const leafKey = path[path.length - 1];
-    if (!(leafKey in cursor))
+    if (!(leafKey in cursor)) {
         return false;
+    }
     delete cursor[leafKey];
     for (let idx = stack.length - 1; idx >= 0; idx -= 1) {
         const { node, key } = stack[idx];
@@ -61,15 +64,10 @@ export function unsetConfigValueAtPath(root, path) {
 export function getConfigValueAtPath(root, path) {
     let cursor = root;
     for (const key of path) {
-        if (!isPlainObject(cursor))
+        if (!isPlainObject(cursor)) {
             return undefined;
+        }
         cursor = cursor[key];
     }
     return cursor;
 }
-function isPlainObject(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        !Array.isArray(value) &&
-        Object.prototype.toString.call(value) === "[object Object]");
-}

package/dist/config/defaults.js

@@ -1,5 +1,5 @@
 import { DEFAULT_CONTEXT_TOKENS } from "../agents/defaults.js";
-import { parseModelRef } from "../agents/model-selection.js";
+import { normalizeProviderId, parseModelRef } from "../agents/model-selection.js";
 import { DEFAULT_AGENT_MAX_CONCURRENT, DEFAULT_SUBAGENT_MAX_CONCURRENT } from "./agent-limits.js";
 import { resolveTalkApiKey } from "./talk.js";
 let defaultWarnState = { warned: false };
@@ -22,6 +22,12 @@ const DEFAULT_MODEL_COST = {
 };
 const DEFAULT_MODEL_INPUT = ["text"];
 const DEFAULT_MODEL_MAX_TOKENS = 8192;
+function resolveDefaultProviderApi(providerId, providerApi) {
+    if (providerApi) {
+        return providerApi;
+    }
+    return normalizeProviderId(providerId) === "anthropic" ? "anthropic-messages" : undefined;
+}
 function isPositiveNumber(value) {
     return typeof value === "number" && Number.isFinite(value) && value > 0;
 }
@@ -135,6 +141,12 @@ export function applyModelDefaults(cfg) {
             if (!Array.isArray(models) || models.length === 0) {
                 continue;
             }
+            const providerApi = resolveDefaultProviderApi(providerId, provider.api);
+            let nextProvider = provider;
+            if (providerApi && provider.api !== providerApi) {
+                mutated = true;
+                nextProvider = { ...nextProvider, api: providerApi };
+            }
             let providerMutated = false;
             const nextModels = models.map((model) => {
                 const raw = model;
@@ -168,6 +180,10 @@ export function applyModelDefaults(cfg) {
                 if (raw.maxTokens !== maxTokens) {
                     modelMutated = true;
                 }
+                const api = raw.api ?? providerApi;
+                if (raw.api !== api) {
+                    modelMutated = true;
+                }
                 if (!modelMutated) {
                     return model;
                 }
@@ -179,12 +195,16 @@ export function applyModelDefaults(cfg) {
                     cost,
                     contextWindow,
                     maxTokens,
+                    api,
                 };
             });
             if (!providerMutated) {
+                if (nextProvider !== provider) {
+                    nextProviders[providerId] = nextProvider;
+                }
                 continue;
             }
-            nextProviders[providerId] = { ...provider, models: nextModels };
+            nextProviders[providerId] = { ...nextProvider, models: nextModels };
             mutated = true;
         }
         if (mutated) {

package/dist/config/discord-preview-streaming.js

@@ -0,0 +1,104 @@
+function normalizeStreamingMode(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const normalized = value.trim().toLowerCase();
+    return normalized || null;
+}
+export function parseStreamingMode(value) {
+    const normalized = normalizeStreamingMode(value);
+    if (normalized === "off" ||
+        normalized === "partial" ||
+        normalized === "block" ||
+        normalized === "progress") {
+        return normalized;
+    }
+    return null;
+}
+export function parseDiscordPreviewStreamMode(value) {
+    const parsed = parseStreamingMode(value);
+    if (!parsed) {
+        return null;
+    }
+    return parsed === "progress" ? "partial" : parsed;
+}
+export function parseSlackLegacyDraftStreamMode(value) {
+    const normalized = normalizeStreamingMode(value);
+    if (normalized === "replace" || normalized === "status_final" || normalized === "append") {
+        return normalized;
+    }
+    return null;
+}
+export function mapSlackLegacyDraftStreamModeToStreaming(mode) {
+    if (mode === "append") {
+        return "block";
+    }
+    if (mode === "status_final") {
+        return "progress";
+    }
+    return "partial";
+}
+export function mapStreamingModeToSlackLegacyDraftStreamMode(mode) {
+    if (mode === "block") {
+        return "append";
+    }
+    if (mode === "progress") {
+        return "status_final";
+    }
+    return "replace";
+}
+export function resolveTelegramPreviewStreamMode(params = {}) {
+    const parsedStreaming = parseStreamingMode(params.streaming);
+    if (parsedStreaming) {
+        if (parsedStreaming === "progress") {
+            return "partial";
+        }
+        return parsedStreaming;
+    }
+    const legacy = parseDiscordPreviewStreamMode(params.streamMode);
+    if (legacy) {
+        return legacy;
+    }
+    if (typeof params.streaming === "boolean") {
+        return params.streaming ? "partial" : "off";
+    }
+    return "off";
+}
+export function resolveDiscordPreviewStreamMode(params = {}) {
+    const parsedStreaming = parseDiscordPreviewStreamMode(params.streaming);
+    if (parsedStreaming) {
+        return parsedStreaming;
+    }
+    const legacy = parseDiscordPreviewStreamMode(params.streamMode);
+    if (legacy) {
+        return legacy;
+    }
+    if (typeof params.streaming === "boolean") {
+        return params.streaming ? "partial" : "off";
+    }
+    return "off";
+}
+export function resolveSlackStreamingMode(params = {}) {
+    const parsedStreaming = parseStreamingMode(params.streaming);
+    if (parsedStreaming) {
+        return parsedStreaming;
+    }
+    const legacyStreamMode = parseSlackLegacyDraftStreamMode(params.streamMode);
+    if (legacyStreamMode) {
+        return mapSlackLegacyDraftStreamModeToStreaming(legacyStreamMode);
+    }
+    // Legacy `streaming` was a Slack native-streaming toggle; preview mode stayed replace.
+    if (typeof params.streaming === "boolean") {
+        return "partial";
+    }
+    return "partial";
+}
+export function resolveSlackNativeStreaming(params = {}) {
+    if (typeof params.nativeStreaming === "boolean") {
+        return params.nativeStreaming;
+    }
+    if (typeof params.streaming === "boolean") {
+        return params.streaming;
+    }
+    return true;
+}

package/dist/config/env-vars.js

@@ -1,26 +1,55 @@
-export function collectConfigEnvVars(cfg) {
+import { isDangerousHostEnvVarName, normalizeEnvVarKey } from "../infra/host-env-security.js";
+function collectConfigEnvVarsByTarget(cfg) {
     const envConfig = cfg?.env;
-    if (!envConfig)
+    if (!envConfig) {
         return {};
+    }
     const entries = {};
     if (envConfig.vars) {
-        for (const [key, value] of Object.entries(envConfig.vars)) {
-            if (!value)
+        for (const [rawKey, value] of Object.entries(envConfig.vars)) {
+            if (!value) {
+                continue;
+            }
+            const key = normalizeEnvVarKey(rawKey, { portable: true });
+            if (!key) {
+                continue;
+            }
+            if (isDangerousHostEnvVarName(key)) {
                 continue;
+            }
             entries[key] = value;
         }
     }
-    for (const [key, value] of Object.entries(envConfig)) {
-        if (key === "shellEnv" || key === "vars")
+    for (const [rawKey, value] of Object.entries(envConfig)) {
+        if (rawKey === "shellEnv" || rawKey === "vars") {
+            continue;
+        }
+        if (typeof value !== "string" || !value.trim()) {
+            continue;
+        }
+        const key = normalizeEnvVarKey(rawKey, { portable: true });
+        if (!key) {
             continue;
-        if (typeof value !== "string" || !value.trim())
+        }
+        if (isDangerousHostEnvVarName(key)) {
             continue;
+        }
         entries[key] = value;
     }
     return entries;
 }
+export function collectConfigRuntimeEnvVars(cfg) {
+    return collectConfigEnvVarsByTarget(cfg);
+}
+export function collectConfigServiceEnvVars(cfg) {
+    return collectConfigEnvVarsByTarget(cfg);
+}
+/** @deprecated Use `collectConfigRuntimeEnvVars` or `collectConfigServiceEnvVars`. */
+export function collectConfigEnvVars(cfg) {
+    return collectConfigRuntimeEnvVars(cfg);
+}
 export function applyConfigEnvVars(cfg, env = process.env) {
-    const entries = collectConfigEnvVars(cfg);
+    const entries = collectConfigRuntimeEnvVars(cfg);
     for (const [key, value] of Object.entries(entries)) {
         if (env[key]?.trim()) {
             continue;

package/dist/config/includes.js

@@ -14,6 +14,7 @@ import path from "node:path";
 import JSON5 from "json5";
 import { isPathInside } from "../security/scan-paths.js";
 import { isPlainObject } from "../utils.js";
+import { isBlockedObjectKey } from "./prototype-keys.js";
 export const INCLUDE_KEY = "$include";
 export const MAX_INCLUDE_DEPTH = 10;
 // ============================================================================
@@ -48,6 +49,9 @@ export function deepMerge(target, source) {
     if (isPlainObject(target) && isPlainObject(source)) {
         const result = { ...target };
         for (const key of Object.keys(source)) {
+            if (isBlockedObjectKey(key)) {
+                continue;
+            }
             result[key] = key in result ? deepMerge(result[key], source[key]) : source[key];
         }
         return result;

package/dist/config/io.js

@@ -51,6 +51,82 @@ function hashConfigRaw(raw) {
         .update(raw ?? "")
         .digest("hex");
 }
+function isNumericPathSegment(raw) {
+    return /^[0-9]+$/.test(raw);
+}
+function isWritePlainObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function unsetPathForWrite(root, pathSegments) {
+    if (pathSegments.length === 0) {
+        return false;
+    }
+    const traversal = [];
+    let cursor = root;
+    for (let i = 0; i < pathSegments.length - 1; i += 1) {
+        const segment = pathSegments[i];
+        if (Array.isArray(cursor)) {
+            if (!isNumericPathSegment(segment)) {
+                return false;
+            }
+            const index = Number.parseInt(segment, 10);
+            if (!Number.isFinite(index) || index < 0 || index >= cursor.length) {
+                return false;
+            }
+            traversal.push({ container: cursor, key: index });
+            cursor = cursor[index];
+            continue;
+        }
+        if (!isWritePlainObject(cursor) || !(segment in cursor)) {
+            return false;
+        }
+        traversal.push({ container: cursor, key: segment });
+        cursor = cursor[segment];
+    }
+    const leaf = pathSegments[pathSegments.length - 1];
+    if (Array.isArray(cursor)) {
+        if (!isNumericPathSegment(leaf)) {
+            return false;
+        }
+        const index = Number.parseInt(leaf, 10);
+        if (!Number.isFinite(index) || index < 0 || index >= cursor.length) {
+            return false;
+        }
+        cursor.splice(index, 1);
+    }
+    else {
+        if (!isWritePlainObject(cursor) || !(leaf in cursor)) {
+            return false;
+        }
+        delete cursor[leaf];
+    }
+    // Prune now-empty object branches after unsetting to avoid dead config scaffolding.
+    for (let i = traversal.length - 1; i >= 0; i -= 1) {
+        const { container, key } = traversal[i];
+        let child;
+        if (Array.isArray(container)) {
+            child = typeof key === "number" ? container[key] : undefined;
+        }
+        else if (isWritePlainObject(container)) {
+            child = container[String(key)];
+        }
+        else {
+            break;
+        }
+        if (!isWritePlainObject(child) || Object.keys(child).length > 0) {
+            break;
+        }
+        if (Array.isArray(container) && typeof key === "number") {
+            if (key >= 0 && key < container.length) {
+                container.splice(key, 1);
+            }
+        }
+        else if (isWritePlainObject(container)) {
+            delete container[String(key)];
+        }
+    }
+    return true;
+}
 export function resolveConfigSnapshotHash(snapshot) {
     if (typeof snapshot.hash === "string") {
         const trimmed = snapshot.hash.trim();
@@ -683,6 +759,14 @@ export function createConfigIO(overrides = {}) {
         const outputConfig = envRefMap && changedPaths
             ? restoreEnvRefsFromMap(cfgToWrite, "", envRefMap, changedPaths)
             : cfgToWrite;
+        if (options.unsetPaths?.length) {
+            for (const unsetPath of options.unsetPaths) {
+                if (!Array.isArray(unsetPath) || unsetPath.length === 0) {
+                    continue;
+                }
+                unsetPathForWrite(outputConfig, unsetPath);
+            }
+        }
         // Do NOT apply runtime defaults when writing — user config should only contain
         // explicitly set values. Runtime defaults are applied when loading (issue #6070).
         const stampedOutputConfig = stampConfigVersion(outputConfig);
@@ -709,7 +793,7 @@ export function createConfigIO(overrides = {}) {
                 return;
             }
             const isVitest = deps.env.VITEST === "true";
-            const shouldLogInVitest = deps.env.CLAWDBOT_TEST_CONFIG_OVERWRITE_LOG === "1";
+            const shouldLogInVitest = deps.env.POOLBOT_TEST_CONFIG_OVERWRITE_LOG === "1";
             if (isVitest && !shouldLogInVitest) {
                 return;
             }
@@ -722,7 +806,7 @@ export function createConfigIO(overrides = {}) {
             }
             // Tests often write minimal configs (missing meta, etc); keep output quiet unless requested.
             const isVitest = deps.env.VITEST === "true";
-            const shouldLogInVitest = deps.env.CLAWDBOT_TEST_CONFIG_WRITE_ANOMALY_LOG === "1";
+            const shouldLogInVitest = deps.env.POOLBOT_TEST_CONFIG_WRITE_ANOMALY_LOG === "1";
             if (isVitest && !shouldLogInVitest) {
                 return;
             }
@@ -738,14 +822,14 @@ export function createConfigIO(overrides = {}) {
             cwd: process.cwd(),
             argv: process.argv.slice(0, 8),
             execArgv: process.execArgv.slice(0, 8),
-            watchMode: deps.env.CLAWDBOT_WATCH_MODE === "1",
-            watchSession: typeof deps.env.CLAWDBOT_WATCH_SESSION === "string" &&
-                deps.env.CLAWDBOT_WATCH_SESSION.trim().length > 0
-                ? deps.env.CLAWDBOT_WATCH_SESSION.trim()
+            watchMode: deps.env.POOLBOT_WATCH_MODE === "1",
+            watchSession: typeof deps.env.POOLBOT_WATCH_SESSION === "string" &&
+                deps.env.POOLBOT_WATCH_SESSION.trim().length > 0
+                ? deps.env.POOLBOT_WATCH_SESSION.trim()
                 : null,
-            watchCommand: typeof deps.env.CLAWDBOT_WATCH_COMMAND === "string" &&
-                deps.env.CLAWDBOT_WATCH_COMMAND.trim().length > 0
-                ? deps.env.CLAWDBOT_WATCH_COMMAND.trim()
+            watchCommand: typeof deps.env.POOLBOT_WATCH_COMMAND === "string" &&
+                deps.env.POOLBOT_WATCH_COMMAND.trim().length > 0
+                ? deps.env.POOLBOT_WATCH_COMMAND.trim()
                 : null,
             existsBefore: snapshot.exists,
             previousHash: previousHash ?? null,
@@ -829,12 +913,12 @@ export function createConfigIO(overrides = {}) {
     };
 }
 // NOTE: These wrappers intentionally do *not* cache the resolved config path at
-// module scope. `CLAWDBOT_CONFIG_PATH` (and friends) are expected to work even
+// module scope. `POOLBOT_CONFIG_PATH` (and friends) are expected to work even
 // when set after the module has been imported (tests, one-off scripts, etc.).
 const DEFAULT_CONFIG_CACHE_MS = 200;
 let configCache = null;
 function resolveConfigCacheMs(env) {
-    const raw = env.CLAWDBOT_CONFIG_CACHE_MS?.trim();
+    const raw = env.POOLBOT_CONFIG_CACHE_MS?.trim();
     if (raw === "" || raw === "0") {
         return 0;
     }
@@ -848,7 +932,7 @@ function resolveConfigCacheMs(env) {
     return Math.max(0, parsed);
 }
 function shouldUseConfigCache(env) {
-    if (env.CLAWDBOT_DISABLE_CONFIG_CACHE?.trim()) {
+    if (env.POOLBOT_DISABLE_CONFIG_CACHE?.trim()) {
         return false;
     }
     return resolveConfigCacheMs(env) > 0;
@@ -890,5 +974,6 @@ export async function writeConfigFile(cfg, options = {}) {
     const sameConfigPath = options.expectedConfigPath === undefined || options.expectedConfigPath === io.configPath;
     await io.writeConfigFile(cfg, {
         envSnapshotForRestore: sameConfigPath ? options.envSnapshotForRestore : undefined,
+        unsetPaths: options.unsetPaths,
     });
 }