@poolzin/pool-bot 2026.2.21 → 2026.2.22

package/dist/routing/resolve-route.js

@@ -1,4 +1,7 @@
 import { resolveDefaultAgentId } from "../agents/agent-scope.js";
+import { normalizeChatType } from "../channels/chat-type.js";
+import { shouldLogVerbose } from "../globals.js";
+import { logDebug } from "../logger.js";
 import { listBindings } from "./bindings.js";
 import { buildAgentMainSessionKey, buildAgentPeerSessionKey, DEFAULT_ACCOUNT_ID, DEFAULT_MAIN_KEY, normalizeAgentId, sanitizeAgentId, } from "./session-key.js";
 export { DEFAULT_ACCOUNT_ID, DEFAULT_AGENT_ID } from "./session-key.js";
@@ -6,7 +9,13 @@ function normalizeToken(value) {
     return (value ?? "").trim().toLowerCase();
 }
 function normalizeId(value) {
-    return (value ?? "").trim();
+    if (typeof value === "string") {
+        return value.trim();
+    }
+    if (typeof value === "number" || typeof value === "bigint") {
+        return String(value).trim();
+    }
+    return "";
 }
 function normalizeAccountId(value) {
     const trimmed = (value ?? "").trim();
@@ -14,10 +23,12 @@ function normalizeAccountId(value) {
 }
 function matchesAccountId(match, actual) {
     const trimmed = (match ?? "").trim();
-    if (!trimmed)
+    if (!trimmed) {
         return actual === DEFAULT_ACCOUNT_ID;
-    if (trimmed === "*")
+    }
+    if (trimmed === "*") {
         return true;
+    }
     return trimmed === actual;
 }
 export function buildAgentSessionKey(params) {
@@ -28,7 +39,7 @@ export function buildAgentSessionKey(params) {
         mainKey: DEFAULT_MAIN_KEY,
         channel,
         accountId: params.accountId,
-        peerKind: peer?.kind ?? "dm",
+        peerKind: peer?.kind ?? "direct",
         peerId: peer ? normalizeId(peer.id) || "unknown" : null,
         dmScope: params.dmScope,
         identityLinks: params.identityLinks,
@@ -40,44 +51,116 @@ function listAgents(cfg) {
 }
 function pickFirstExistingAgentId(cfg, agentId) {
     const trimmed = (agentId ?? "").trim();
-    if (!trimmed)
+    if (!trimmed) {
         return sanitizeAgentId(resolveDefaultAgentId(cfg));
+    }
     const normalized = normalizeAgentId(trimmed);
     const agents = listAgents(cfg);
-    if (agents.length === 0)
+    if (agents.length === 0) {
         return sanitizeAgentId(trimmed);
+    }
     const match = agents.find((agent) => normalizeAgentId(agent.id) === normalized);
-    if (match?.id?.trim())
+    if (match?.id?.trim()) {
         return sanitizeAgentId(match.id.trim());
+    }
     return sanitizeAgentId(resolveDefaultAgentId(cfg));
 }
 function matchesChannel(match, channel) {
     const key = normalizeToken(match?.channel);
-    if (!key)
+    if (!key) {
         return false;
+    }
     return key === channel;
 }
-function matchesPeer(match, peer) {
-    const m = match?.peer;
-    if (!m)
+const evaluatedBindingsCacheByCfg = new WeakMap();
+const MAX_EVALUATED_BINDINGS_CACHE_KEYS = 2000;
+function getEvaluatedBindingsForChannelAccount(cfg, channel, accountId) {
+    const bindingsRef = cfg.bindings;
+    const existing = evaluatedBindingsCacheByCfg.get(cfg);
+    const cache = existing && existing.bindingsRef === bindingsRef
+        ? existing
+        : { bindingsRef, byChannelAccount: new Map() };
+    if (cache !== existing) {
+        evaluatedBindingsCacheByCfg.set(cfg, cache);
+    }
+    const cacheKey = `${channel}\t${accountId}`;
+    const hit = cache.byChannelAccount.get(cacheKey);
+    if (hit) {
+        return hit;
+    }
+    const evaluated = listBindings(cfg).flatMap((binding) => {
+        if (!binding || typeof binding !== "object") {
+            return [];
+        }
+        if (!matchesChannel(binding.match, channel)) {
+            return [];
+        }
+        if (!matchesAccountId(binding.match?.accountId, accountId)) {
+            return [];
+        }
+        return [{ binding, match: normalizeBindingMatch(binding.match) }];
+    });
+    cache.byChannelAccount.set(cacheKey, evaluated);
+    if (cache.byChannelAccount.size > MAX_EVALUATED_BINDINGS_CACHE_KEYS) {
+        cache.byChannelAccount.clear();
+        cache.byChannelAccount.set(cacheKey, evaluated);
+    }
+    return evaluated;
+}
+function normalizePeerConstraint(peer) {
+    if (!peer) {
+        return { state: "none" };
+    }
+    const kind = normalizeChatType(peer.kind);
+    const id = normalizeId(peer.id);
+    if (!kind || !id) {
+        return { state: "invalid" };
+    }
+    return { state: "valid", kind, id };
+}
+function normalizeBindingMatch(match) {
+    const rawRoles = match?.roles;
+    return {
+        accountPattern: (match?.accountId ?? "").trim(),
+        peer: normalizePeerConstraint(match?.peer),
+        guildId: normalizeId(match?.guildId) || null,
+        teamId: normalizeId(match?.teamId) || null,
+        roles: Array.isArray(rawRoles) && rawRoles.length > 0 ? rawRoles : null,
+    };
+}
+function hasGuildConstraint(match) {
+    return Boolean(match.guildId);
+}
+function hasTeamConstraint(match) {
+    return Boolean(match.teamId);
+}
+function hasRolesConstraint(match) {
+    return Boolean(match.roles);
+}
+function matchesBindingScope(match, scope) {
+    if (match.peer.state === "invalid") {
         return false;
-    const kind = normalizeToken(m.kind);
-    const id = normalizeId(m.id);
-    if (!kind || !id)
+    }
+    if (match.peer.state === "valid") {
+        if (!scope.peer || scope.peer.kind !== match.peer.kind || scope.peer.id !== match.peer.id) {
+            return false;
+        }
+    }
+    if (match.guildId && match.guildId !== scope.guildId) {
         return false;
-    return kind === peer.kind && id === peer.id;
-}
-function matchesGuild(match, guildId) {
-    const id = normalizeId(match?.guildId);
-    if (!id)
+    }
+    if (match.teamId && match.teamId !== scope.teamId) {
         return false;
-    return id === guildId;
-}
-function matchesTeam(match, teamId) {
-    const id = normalizeId(match?.teamId);
-    if (!id)
+    }
+    if (match.roles) {
+        for (const role of match.roles) {
+            if (scope.memberRoleIds.has(role)) {
+                return true;
+            }
+        }
         return false;
-    return id === teamId;
+    }
+    return true;
 }
 export function resolveAgentRoute(input) {
     const channel = normalizeToken(input.channel);
@@ -85,13 +168,9 @@ export function resolveAgentRoute(input) {
     const peer = input.peer ? { kind: input.peer.kind, id: normalizeId(input.peer.id) } : null;
     const guildId = normalizeId(input.guildId);
     const teamId = normalizeId(input.teamId);
-    const bindings = listBindings(input.cfg).filter((binding) => {
-        if (!binding || typeof binding !== "object")
-            return false;
-        if (!matchesChannel(binding.match, channel))
-            return false;
-        return matchesAccountId(binding.match?.accountId, accountId);
-    });
+    const memberRoleIds = input.memberRoleIds ?? [];
+    const memberRoleIdSet = new Set(memberRoleIds);
+    const bindings = getEvaluatedBindingsForChannelAccount(input.cfg, channel, accountId);
     const dmScope = input.cfg.session?.dmScope ?? "main";
     const identityLinks = input.cfg.session?.identityLinks;
     const choose = (agentId, matchedBy) => {
@@ -117,36 +196,91 @@ export function resolveAgentRoute(input) {
             matchedBy,
         };
     };
-    if (peer) {
-        const peerMatch = bindings.find((b) => matchesPeer(b.match, peer));
-        if (peerMatch)
-            return choose(peerMatch.agentId, "binding.peer");
+    const shouldLogDebug = shouldLogVerbose();
+    const formatPeer = (value) => value?.kind && value?.id ? `${value.kind}:${value.id}` : "none";
+    const formatNormalizedPeer = (value) => {
+        if (value.state === "none") {
+            return "none";
+        }
+        if (value.state === "invalid") {
+            return "invalid";
+        }
+        return `${value.kind}:${value.id}`;
+    };
+    if (shouldLogDebug) {
+        logDebug(`[routing] resolveAgentRoute: channel=${channel} accountId=${accountId} peer=${formatPeer(peer)} guildId=${guildId || "none"} teamId=${teamId || "none"} bindings=${bindings.length}`);
+        for (const entry of bindings) {
+            logDebug(`[routing] binding: agentId=${entry.binding.agentId} accountPattern=${entry.match.accountPattern || "default"} peer=${formatNormalizedPeer(entry.match.peer)} guildId=${entry.match.guildId ?? "none"} teamId=${entry.match.teamId ?? "none"} roles=${entry.match.roles?.length ?? 0}`);
+        }
     }
     // Thread parent inheritance: if peer (thread) didn't match, check parent peer binding
     const parentPeer = input.parentPeer
         ? { kind: input.parentPeer.kind, id: normalizeId(input.parentPeer.id) }
         : null;
-    if (parentPeer && parentPeer.id) {
-        const parentPeerMatch = bindings.find((b) => matchesPeer(b.match, parentPeer));
-        if (parentPeerMatch) {
-            return choose(parentPeerMatch.agentId, "binding.peer.parent");
+    const baseScope = {
+        guildId,
+        teamId,
+        memberRoleIds: memberRoleIdSet,
+    };
+    const tiers = [
+        {
+            matchedBy: "binding.peer",
+            enabled: Boolean(peer),
+            scopePeer: peer,
+            predicate: (candidate) => candidate.match.peer.state === "valid",
+        },
+        {
+            matchedBy: "binding.peer.parent",
+            enabled: Boolean(parentPeer && parentPeer.id),
+            scopePeer: parentPeer && parentPeer.id ? parentPeer : null,
+            predicate: (candidate) => candidate.match.peer.state === "valid",
+        },
+        {
+            matchedBy: "binding.guild+roles",
+            enabled: Boolean(guildId && memberRoleIds.length > 0),
+            scopePeer: peer,
+            predicate: (candidate) => hasGuildConstraint(candidate.match) && hasRolesConstraint(candidate.match),
+        },
+        {
+            matchedBy: "binding.guild",
+            enabled: Boolean(guildId),
+            scopePeer: peer,
+            predicate: (candidate) => hasGuildConstraint(candidate.match) && !hasRolesConstraint(candidate.match),
+        },
+        {
+            matchedBy: "binding.team",
+            enabled: Boolean(teamId),
+            scopePeer: peer,
+            predicate: (candidate) => hasTeamConstraint(candidate.match),
+        },
+        {
+            matchedBy: "binding.account",
+            enabled: true,
+            scopePeer: peer,
+            predicate: (candidate) => candidate.match.accountPattern !== "*",
+        },
+        {
+            matchedBy: "binding.channel",
+            enabled: true,
+            scopePeer: peer,
+            predicate: (candidate) => candidate.match.accountPattern === "*",
+        },
+    ];
+    for (const tier of tiers) {
+        if (!tier.enabled) {
+            continue;
+        }
+        const matched = bindings.find((candidate) => tier.predicate(candidate) &&
+            matchesBindingScope(candidate.match, {
+                ...baseScope,
+                peer: tier.scopePeer,
+            }));
+        if (matched) {
+            if (shouldLogDebug) {
+                logDebug(`[routing] match: matchedBy=${tier.matchedBy} agentId=${matched.binding.agentId}`);
+            }
+            return choose(matched.binding.agentId, tier.matchedBy);
         }
     }
-    if (guildId) {
-        const guildMatch = bindings.find((b) => matchesGuild(b.match, guildId));
-        if (guildMatch)
-            return choose(guildMatch.agentId, "binding.guild");
-    }
-    if (teamId) {
-        const teamMatch = bindings.find((b) => matchesTeam(b.match, teamId));
-        if (teamMatch)
-            return choose(teamMatch.agentId, "binding.team");
-    }
-    const accountMatch = bindings.find((b) => b.match?.accountId?.trim() !== "*" && !b.match?.peer && !b.match?.guildId && !b.match?.teamId);
-    if (accountMatch)
-        return choose(accountMatch.agentId, "binding.account");
-    const anyAccountMatch = bindings.find((b) => b.match?.accountId?.trim() === "*" && !b.match?.peer && !b.match?.guildId && !b.match?.teamId);
-    if (anyAccountMatch)
-        return choose(anyAccountMatch.agentId, "binding.channel");
     return choose(resolveDefaultAgentId(input.cfg), "default");
 }

package/dist/routing/session-key.js

@@ -1,5 +1,5 @@
 import { parseAgentSessionKey } from "../sessions/session-key-utils.js";
-export { isAcpSessionKey, isSubagentSessionKey, parseAgentSessionKey, } from "../sessions/session-key-utils.js";
+export { getSubagentDepth, isCronSessionKey, isAcpSessionKey, isSubagentSessionKey, parseAgentSessionKey, } from "../sessions/session-key-utils.js";
 export const DEFAULT_AGENT_ID = "main";
 export const DEFAULT_MAIN_KEY = "main";
 export const DEFAULT_ACCOUNT_ID = "default";
@@ -17,8 +17,9 @@ export function normalizeMainKey(value) {
 }
 export function toAgentRequestSessionKey(storeKey) {
     const raw = (storeKey ?? "").trim();
-    if (!raw)
+    if (!raw) {
         return undefined;
+    }
     return parseAgentSessionKey(raw)?.rest ?? raw;
 }
 export function toAgentStoreSessionKey(params) {
@@ -27,8 +28,9 @@ export function toAgentStoreSessionKey(params) {
         return buildAgentMainSessionKey({ agentId: params.agentId, mainKey: params.mainKey });
     }
     const lowered = raw.toLowerCase();
-    if (lowered.startsWith("agent:"))
+    if (lowered.startsWith("agent:")) {
         return lowered;
+    }
     if (lowered.startsWith("subagent:")) {
         return `agent:${normalizeAgentId(params.agentId)}:${lowered}`;
     }
@@ -50,11 +52,13 @@ export function classifySessionKeyShape(sessionKey) {
 }
 export function normalizeAgentId(value) {
     const trimmed = (value ?? "").trim();
-    if (!trimmed)
+    if (!trimmed) {
         return DEFAULT_AGENT_ID;
+    }
     // Keep it path-safe + shell-friendly.
-    if (VALID_ID_RE.test(trimmed))
+    if (VALID_ID_RE.test(trimmed)) {
         return trimmed.toLowerCase();
+    }
     // Best-effort fallback: collapse invalid characters to "-"
     return (trimmed
         .toLowerCase()
@@ -65,10 +69,12 @@ export function normalizeAgentId(value) {
 }
 export function sanitizeAgentId(value) {
     const trimmed = (value ?? "").trim();
-    if (!trimmed)
+    if (!trimmed) {
         return DEFAULT_AGENT_ID;
-    if (VALID_ID_RE.test(trimmed))
+    }
+    if (VALID_ID_RE.test(trimmed)) {
         return trimmed.toLowerCase();
+    }
     return (trimmed
         .toLowerCase()
         .replace(INVALID_CHARS_RE, "-")
@@ -78,10 +84,12 @@ export function sanitizeAgentId(value) {
 }
 export function normalizeAccountId(value) {
     const trimmed = (value ?? "").trim();
-    if (!trimmed)
+    if (!trimmed) {
         return DEFAULT_ACCOUNT_ID;
-    if (VALID_ID_RE.test(trimmed))
+    }
+    if (VALID_ID_RE.test(trimmed)) {
         return trimmed.toLowerCase();
+    }
     return (trimmed
         .toLowerCase()
         .replace(INVALID_CHARS_RE, "-")
@@ -95,8 +103,8 @@ export function buildAgentMainSessionKey(params) {
     return `agent:${agentId}:${mainKey}`;
 }
 export function buildAgentPeerSessionKey(params) {
-    const peerKind = params.peerKind ?? "dm";
-    if (peerKind === "dm") {
+    const peerKind = params.peerKind ?? "direct";
+    if (peerKind === "direct") {
         const dmScope = params.dmScope ?? "main";
         let peerId = (params.peerId ?? "").trim();
         const linkedPeerId = dmScope === "main"
@@ -106,20 +114,21 @@ export function buildAgentPeerSessionKey(params) {
                 channel: params.channel,
                 peerId,
             });
-        if (linkedPeerId)
+        if (linkedPeerId) {
             peerId = linkedPeerId;
+        }
         peerId = peerId.toLowerCase();
         if (dmScope === "per-account-channel-peer" && peerId) {
             const channel = (params.channel ?? "").trim().toLowerCase() || "unknown";
             const accountId = normalizeAccountId(params.accountId);
-            return `agent:${normalizeAgentId(params.agentId)}:${channel}:${accountId}:dm:${peerId}`;
+            return `agent:${normalizeAgentId(params.agentId)}:${channel}:${accountId}:direct:${peerId}`;
         }
         if (dmScope === "per-channel-peer" && peerId) {
             const channel = (params.channel ?? "").trim().toLowerCase() || "unknown";
-            return `agent:${normalizeAgentId(params.agentId)}:${channel}:dm:${peerId}`;
+            return `agent:${normalizeAgentId(params.agentId)}:${channel}:direct:${peerId}`;
         }
         if (dmScope === "per-peer" && peerId) {
-            return `agent:${normalizeAgentId(params.agentId)}:dm:${peerId}`;
+            return `agent:${normalizeAgentId(params.agentId)}:direct:${peerId}`;
         }
         return buildAgentMainSessionKey({
             agentId: params.agentId,
@@ -132,29 +141,36 @@ export function buildAgentPeerSessionKey(params) {
 }
 function resolveLinkedPeerId(params) {
     const identityLinks = params.identityLinks;
-    if (!identityLinks)
+    if (!identityLinks) {
         return null;
+    }
     const peerId = params.peerId.trim();
-    if (!peerId)
+    if (!peerId) {
         return null;
+    }
     const candidates = new Set();
     const rawCandidate = normalizeToken(peerId);
-    if (rawCandidate)
+    if (rawCandidate) {
         candidates.add(rawCandidate);
+    }
     const channel = normalizeToken(params.channel);
     if (channel) {
         const scopedCandidate = normalizeToken(`${channel}:${peerId}`);
-        if (scopedCandidate)
+        if (scopedCandidate) {
             candidates.add(scopedCandidate);
+        }
     }
-    if (candidates.size === 0)
+    if (candidates.size === 0) {
         return null;
+    }
     for (const [canonical, ids] of Object.entries(identityLinks)) {
         const canonicalName = canonical.trim();
-        if (!canonicalName)
+        if (!canonicalName) {
             continue;
-        if (!Array.isArray(ids))
+        }
+        if (!Array.isArray(ids)) {
             continue;
+        }
         for (const id of ids) {
             const normalized = normalizeToken(id);
             if (normalized && candidates.has(normalized)) {

package/dist/runtime.js

@@ -1,17 +1,43 @@
 import { clearActiveProgressLine } from "./terminal/progress-line.js";
 import { restoreTerminalState } from "./terminal/restore.js";
+function shouldEmitRuntimeLog(env = process.env) {
+    if (env.VITEST !== "true") {
+        return true;
+    }
+    if (env.POOLBOT_TEST_RUNTIME_LOG === "1") {
+        return true;
+    }
+    const maybeMockedLog = console.log;
+    return typeof maybeMockedLog.mock === "object";
+}
+function createRuntimeIo() {
+    return {
+        log: (...args) => {
+            if (!shouldEmitRuntimeLog()) {
+                return;
+            }
+            clearActiveProgressLine();
+            console.log(...args);
+        },
+        error: (...args) => {
+            clearActiveProgressLine();
+            console.error(...args);
+        },
+    };
+}
 export const defaultRuntime = {
-    log: (...args) => {
-        clearActiveProgressLine();
-        console.log(...args);
-    },
-    error: (...args) => {
-        clearActiveProgressLine();
-        console.error(...args);
-    },
+    ...createRuntimeIo(),
     exit: (code) => {
-        restoreTerminalState("runtime exit");
+        restoreTerminalState("runtime exit", { resumeStdinIfPaused: false });
         process.exit(code);
         throw new Error("unreachable"); // satisfies tests when mocked
     },
 };
+export function createNonExitingRuntime() {
+    return {
+        ...createRuntimeIo(),
+        exit: (code) => {
+            throw new Error(`exit ${code}`);
+        },
+    };
+}

package/dist/security/audit-channel.js

@@ -90,7 +90,7 @@ export async function collectChannelSecurityFindings(params) {
                 title: `${input.label} DMs share the main session`,
                 detail: "Multiple DM senders currently share the main session, which can leak context across users.",
                 remediation: "Run: " +
-                    formatCliCommand('openclaw config set session.dmScope "per-channel-peer"') +
+                    formatCliCommand('poolbot config set session.dmScope "per-channel-peer"') +
                     ' (or "per-account-channel-peer" for multi-account channels) to isolate DM sessions per sender.',
             });
         }

package/dist/sessions/session-key-utils.js

@@ -1,16 +1,20 @@
 export function parseAgentSessionKey(sessionKey) {
     const raw = (sessionKey ?? "").trim();
-    if (!raw)
+    if (!raw) {
         return null;
+    }
     const parts = raw.split(":").filter(Boolean);
-    if (parts.length < 3)
+    if (parts.length < 3) {
         return null;
-    if (parts[0] !== "agent")
+    }
+    if (parts[0] !== "agent") {
         return null;
+    }
     const agentId = parts[1]?.trim();
     const rest = parts.slice(2).join(":");
-    if (!agentId || !rest)
+    if (!agentId || !rest) {
         return null;
+    }
     return { agentId, rest };
 }
 export function isCronRunSessionKey(sessionKey) {
@@ -20,12 +24,21 @@ export function isCronRunSessionKey(sessionKey) {
     }
     return /^cron:[^:]+:run:[^:]+$/.test(parsed.rest);
 }
+export function isCronSessionKey(sessionKey) {
+    const parsed = parseAgentSessionKey(sessionKey);
+    if (!parsed) {
+        return false;
+    }
+    return parsed.rest.toLowerCase().startsWith("cron:");
+}
 export function isSubagentSessionKey(sessionKey) {
     const raw = (sessionKey ?? "").trim();
-    if (!raw)
+    if (!raw) {
         return false;
-    if (raw.toLowerCase().startsWith("subagent:"))
+    }
+    if (raw.toLowerCase().startsWith("subagent:")) {
         return true;
+    }
     const parsed = parseAgentSessionKey(raw);
     return Boolean((parsed?.rest ?? "").toLowerCase().startsWith("subagent:"));
 }
@@ -38,28 +51,33 @@ export function getSubagentDepth(sessionKey) {
 }
 export function isAcpSessionKey(sessionKey) {
     const raw = (sessionKey ?? "").trim();
-    if (!raw)
+    if (!raw) {
         return false;
+    }
     const normalized = raw.toLowerCase();
-    if (normalized.startsWith("acp:"))
+    if (normalized.startsWith("acp:")) {
         return true;
+    }
     const parsed = parseAgentSessionKey(raw);
     return Boolean((parsed?.rest ?? "").toLowerCase().startsWith("acp:"));
 }
 const THREAD_SESSION_MARKERS = [":thread:", ":topic:"];
 export function resolveThreadParentSessionKey(sessionKey) {
     const raw = (sessionKey ?? "").trim();
-    if (!raw)
+    if (!raw) {
         return null;
+    }
     const normalized = raw.toLowerCase();
     let idx = -1;
     for (const marker of THREAD_SESSION_MARKERS) {
         const candidate = normalized.lastIndexOf(marker);
-        if (candidate > idx)
+        if (candidate > idx) {
             idx = candidate;
+        }
     }
-    if (idx <= 0)
+    if (idx <= 0) {
         return null;
+    }
     const parent = raw.slice(0, idx).trim();
     return parent ? parent : null;
 }

package/dist/shared/frontmatter.js

@@ -24,7 +24,7 @@ export function parseFrontmatterBool(value, fallback) {
     const parsed = parseBooleanValue(value);
     return parsed === undefined ? fallback : parsed;
 }
-export function resolveOpenClawManifestBlock(params) {
+export function resolvePoolbotManifestBlock(params) {
     const raw = getFrontmatterString(params.frontmatter, params.key ?? "metadata");
     if (!raw) {
         return undefined;
@@ -47,7 +47,7 @@ export function resolveOpenClawManifestBlock(params) {
         return undefined;
     }
 }
-export function resolveOpenClawManifestRequires(metadataObj) {
+export function resolvePoolbotManifestRequires(metadataObj) {
     const requiresRaw = typeof metadataObj.requires === "object" && metadataObj.requires !== null
         ? metadataObj.requires
         : undefined;
@@ -61,16 +61,16 @@ export function resolveOpenClawManifestRequires(metadataObj) {
         config: normalizeStringList(requiresRaw.config),
     };
 }
-export function resolveOpenClawManifestInstall(metadataObj, parseInstallSpec) {
+export function resolvePoolbotManifestInstall(metadataObj, parseInstallSpec) {
     const installRaw = Array.isArray(metadataObj.install) ? metadataObj.install : [];
     return installRaw
         .map((entry) => parseInstallSpec(entry))
         .filter((entry) => Boolean(entry));
 }
-export function resolveOpenClawManifestOs(metadataObj) {
+export function resolvePoolbotManifestOs(metadataObj) {
     return normalizeStringList(metadataObj.os);
 }
-export function parseOpenClawManifestInstallBase(input, allowedKinds) {
+export function parsePoolbotManifestInstallBase(input, allowedKinds) {
     if (!input || typeof input !== "object") {
         return undefined;
     }

package/dist/shared/node-list-types.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/string-normalization.js

@@ -0,0 +1,15 @@
+export function normalizeStringEntries(list) {
+    return (list ?? []).map((entry) => String(entry).trim()).filter(Boolean);
+}
+export function normalizeStringEntriesLower(list) {
+    return normalizeStringEntries(list).map((entry) => entry.toLowerCase());
+}
+export function normalizeHyphenSlug(raw) {
+    const trimmed = raw?.trim().toLowerCase() ?? "";
+    if (!trimmed) {
+        return "";
+    }
+    const dashed = trimmed.replace(/\s+/g, "-");
+    const cleaned = dashed.replace(/[^a-z0-9#@._+-]+/g, "-");
+    return cleaned.replace(/-{2,}/g, "-").replace(/^[-.]+|[-.]+$/g, "");
+}