@poolzin/pool-bot 2026.3.26 → 2026.3.28

package/dist/commands/agent.js

@@ -1,536 +0,0 @@
-import path from "node:path";
-import { listAgentIds, resolveAgentDir, resolveEffectiveModelFallbacks, resolveAgentModelPrimary, resolveAgentSkillsFilter, resolveAgentWorkspaceDir, } from "../agents/agent-scope.js";
-import { ensureAuthProfileStore } from "../agents/auth-profiles.js";
-import { clearSessionAuthProfileOverride } from "../agents/auth-profiles/session-override.js";
-import { runCliAgent } from "../agents/cli-runner.js";
-import { getCliSessionId } from "../agents/cli-session.js";
-import { DEFAULT_MODEL, DEFAULT_PROVIDER } from "../agents/defaults.js";
-import { AGENT_LANE_SUBAGENT } from "../agents/lanes.js";
-import { loadModelCatalog } from "../agents/model-catalog.js";
-import { runWithModelFallback } from "../agents/model-fallback.js";
-import { buildAllowedModelSet, isCliProvider, modelKey, normalizeModelRef, resolveConfiguredModelRef, resolveThinkingDefault, } from "../agents/model-selection.js";
-import { runEmbeddedPiAgent } from "../agents/pi-embedded.js";
-import { buildWorkspaceSkillSnapshot } from "../agents/skills.js";
-import { getSkillsSnapshotVersion } from "../agents/skills/refresh.js";
-import { resolveAgentTimeoutMs } from "../agents/timeout.js";
-import { ensureAgentWorkspace } from "../agents/workspace.js";
-import { formatThinkingLevels, formatXHighModelHint, normalizeThinkLevel, normalizeVerboseLevel, supportsXHighThinking, } from "../auto-reply/thinking.js";
-import { formatCliCommand } from "../cli/command-format.js";
-import { createDefaultDeps } from "../cli/deps.js";
-import { loadConfig } from "../config/config.js";
-import { parseSessionThreadInfo, resolveAndPersistSessionFile, resolveAgentIdFromSessionKey, resolveSessionFilePath, resolveSessionTranscriptPath, updateSessionStore, } from "../config/sessions.js";
-import { clearAgentRunContext, emitAgentEvent, registerAgentRunContext, } from "../infra/agent-events.js";
-import { getRemoteSkillEligibility } from "../infra/skills-remote.js";
-import { normalizeAgentId } from "../routing/session-key.js";
-import { defaultRuntime } from "../runtime.js";
-import { applyVerboseOverride } from "../sessions/level-overrides.js";
-import { applyModelOverrideToSessionEntry } from "../sessions/model-overrides.js";
-import { resolveSendPolicy } from "../sessions/send-policy.js";
-import { resolveMessageChannel } from "../utils/message-channel.js";
-import { deliverAgentCommandResult } from "./agent/delivery.js";
-import { resolveAgentRunContext } from "./agent/run-context.js";
-import { updateSessionStoreAfterAgentRun } from "./agent/session-store.js";
-import { resolveSession } from "./agent/session.js";
-async function persistSessionEntry(params) {
-    params.sessionStore[params.sessionKey] = params.entry;
-    await updateSessionStore(params.storePath, (store) => {
-        store[params.sessionKey] = params.entry;
-    });
-}
-function resolveFallbackRetryPrompt(params) {
-    if (!params.isFallbackRetry) {
-        return params.body;
-    }
-    return "Continue where you left off. The previous model attempt failed or timed out.";
-}
-function runAgentAttempt(params) {
-    const effectivePrompt = resolveFallbackRetryPrompt({
-        body: params.body,
-        isFallbackRetry: params.isFallbackRetry,
-    });
-    if (isCliProvider(params.providerOverride, params.cfg)) {
-        const cliSessionId = getCliSessionId(params.sessionEntry, params.providerOverride);
-        return runCliAgent({
-            sessionId: params.sessionId,
-            sessionKey: params.sessionKey,
-            agentId: params.sessionAgentId,
-            sessionFile: params.sessionFile,
-            workspaceDir: params.workspaceDir,
-            config: params.cfg,
-            prompt: effectivePrompt,
-            provider: params.providerOverride,
-            model: params.modelOverride,
-            thinkLevel: params.resolvedThinkLevel,
-            timeoutMs: params.timeoutMs,
-            runId: params.runId,
-            extraSystemPrompt: params.opts.extraSystemPrompt,
-            cliSessionId,
-            images: params.isFallbackRetry ? undefined : params.opts.images,
-            streamParams: params.opts.streamParams,
-        });
-    }
-    const authProfileId = params.providerOverride === params.primaryProvider
-        ? params.sessionEntry?.authProfileOverride
-        : undefined;
-    return runEmbeddedPiAgent({
-        sessionId: params.sessionId,
-        sessionKey: params.sessionKey,
-        agentId: params.sessionAgentId,
-        messageChannel: params.messageChannel,
-        agentAccountId: params.runContext.accountId,
-        messageTo: params.opts.replyTo ?? params.opts.to,
-        messageThreadId: params.opts.threadId,
-        groupId: params.runContext.groupId,
-        groupChannel: params.runContext.groupChannel,
-        groupSpace: params.runContext.groupSpace,
-        spawnedBy: params.spawnedBy,
-        currentChannelId: params.runContext.currentChannelId,
-        currentThreadTs: params.runContext.currentThreadTs,
-        replyToMode: params.runContext.replyToMode,
-        hasRepliedRef: params.runContext.hasRepliedRef,
-        senderIsOwner: true,
-        sessionFile: params.sessionFile,
-        workspaceDir: params.workspaceDir,
-        config: params.cfg,
-        skillsSnapshot: params.skillsSnapshot,
-        prompt: effectivePrompt,
-        images: params.isFallbackRetry ? undefined : params.opts.images,
-        clientTools: params.opts.clientTools,
-        provider: params.providerOverride,
-        model: params.modelOverride,
-        authProfileId,
-        authProfileIdSource: authProfileId ? params.sessionEntry?.authProfileOverrideSource : undefined,
-        thinkLevel: params.resolvedThinkLevel,
-        verboseLevel: params.resolvedVerboseLevel,
-        timeoutMs: params.timeoutMs,
-        runId: params.runId,
-        lane: params.opts.lane,
-        abortSignal: params.opts.abortSignal,
-        extraSystemPrompt: params.opts.extraSystemPrompt,
-        inputProvenance: params.opts.inputProvenance,
-        streamParams: params.opts.streamParams,
-        agentDir: params.agentDir,
-        onAgentEvent: params.onAgentEvent,
-    });
-}
-export async function agentCommand(opts, runtime = defaultRuntime, deps = createDefaultDeps()) {
-    const body = (opts.message ?? "").trim();
-    if (!body) {
-        throw new Error("Message (--message) is required");
-    }
-    if (!opts.to && !opts.sessionId && !opts.sessionKey && !opts.agentId) {
-        throw new Error("Pass --to <E.164>, --session-id, or --agent to choose a session");
-    }
-    const cfg = loadConfig();
-    const agentIdOverrideRaw = opts.agentId?.trim();
-    const agentIdOverride = agentIdOverrideRaw ? normalizeAgentId(agentIdOverrideRaw) : undefined;
-    if (agentIdOverride) {
-        const knownAgents = listAgentIds(cfg);
-        if (!knownAgents.includes(agentIdOverride)) {
-            throw new Error(`Unknown agent id "${agentIdOverrideRaw}". Use "${formatCliCommand("poolbot agents list")}" to see configured agents.`);
-        }
-    }
-    if (agentIdOverride && opts.sessionKey) {
-        const sessionAgentId = resolveAgentIdFromSessionKey(opts.sessionKey);
-        if (sessionAgentId !== agentIdOverride) {
-            throw new Error(`Agent id "${agentIdOverrideRaw}" does not match session key agent "${sessionAgentId}".`);
-        }
-    }
-    const agentCfg = cfg.agents?.defaults;
-    const sessionAgentId = agentIdOverride ?? resolveAgentIdFromSessionKey(opts.sessionKey?.trim());
-    const workspaceDirRaw = resolveAgentWorkspaceDir(cfg, sessionAgentId);
-    const agentDir = resolveAgentDir(cfg, sessionAgentId);
-    const workspace = await ensureAgentWorkspace({
-        dir: workspaceDirRaw,
-        ensureBootstrapFiles: !agentCfg?.skipBootstrap,
-    });
-    const workspaceDir = workspace.dir;
-    const configuredModel = resolveConfiguredModelRef({
-        cfg,
-        defaultProvider: DEFAULT_PROVIDER,
-        defaultModel: DEFAULT_MODEL,
-    });
-    const thinkingLevelsHint = formatThinkingLevels(configuredModel.provider, configuredModel.model);
-    const thinkOverride = normalizeThinkLevel(opts.thinking);
-    const thinkOnce = normalizeThinkLevel(opts.thinkingOnce);
-    if (opts.thinking && !thinkOverride) {
-        throw new Error(`Invalid thinking level. Use one of: ${thinkingLevelsHint}.`);
-    }
-    if (opts.thinkingOnce && !thinkOnce) {
-        throw new Error(`Invalid one-shot thinking level. Use one of: ${thinkingLevelsHint}.`);
-    }
-    const verboseOverride = normalizeVerboseLevel(opts.verbose);
-    if (opts.verbose && !verboseOverride) {
-        throw new Error('Invalid verbose level. Use "on", "full", or "off".');
-    }
-    const laneRaw = typeof opts.lane === "string" ? opts.lane.trim() : "";
-    const isSubagentLane = laneRaw === String(AGENT_LANE_SUBAGENT);
-    const timeoutSecondsRaw = opts.timeout !== undefined
-        ? Number.parseInt(String(opts.timeout), 10)
-        : isSubagentLane
-            ? 0
-            : undefined;
-    if (timeoutSecondsRaw !== undefined &&
-        (Number.isNaN(timeoutSecondsRaw) || timeoutSecondsRaw < 0)) {
-        throw new Error("--timeout must be a non-negative integer (seconds; 0 means no timeout)");
-    }
-    const timeoutMs = resolveAgentTimeoutMs({
-        cfg,
-        overrideSeconds: timeoutSecondsRaw,
-    });
-    const sessionResolution = resolveSession({
-        cfg,
-        to: opts.to,
-        sessionId: opts.sessionId,
-        sessionKey: opts.sessionKey,
-        agentId: agentIdOverride,
-    });
-    const { sessionId, sessionKey, sessionEntry: resolvedSessionEntry, sessionStore, storePath, isNewSession, persistedThinking, persistedVerbose, } = sessionResolution;
-    let sessionEntry = resolvedSessionEntry;
-    const runId = opts.runId?.trim() || sessionId;
-    try {
-        if (opts.deliver === true) {
-            const sendPolicy = resolveSendPolicy({
-                cfg,
-                entry: sessionEntry,
-                sessionKey,
-                channel: sessionEntry?.channel,
-                chatType: sessionEntry?.chatType,
-            });
-            if (sendPolicy === "deny") {
-                throw new Error("send blocked by session policy");
-            }
-        }
-        let resolvedThinkLevel = thinkOnce ??
-            thinkOverride ??
-            persistedThinking ??
-            agentCfg?.thinkingDefault;
-        const resolvedVerboseLevel = verboseOverride ?? persistedVerbose ?? agentCfg?.verboseDefault;
-        if (sessionKey) {
-            registerAgentRunContext(runId, {
-                sessionKey,
-                verboseLevel: resolvedVerboseLevel,
-            });
-        }
-        const needsSkillsSnapshot = isNewSession || !sessionEntry?.skillsSnapshot;
-        const skillsSnapshotVersion = getSkillsSnapshotVersion(workspaceDir);
-        const skillFilter = resolveAgentSkillsFilter(cfg, sessionAgentId);
-        const skillsSnapshot = needsSkillsSnapshot
-            ? buildWorkspaceSkillSnapshot(workspaceDir, {
-                config: cfg,
-                eligibility: { remote: getRemoteSkillEligibility() },
-                snapshotVersion: skillsSnapshotVersion,
-                skillFilter,
-            })
-            : sessionEntry?.skillsSnapshot;
-        if (skillsSnapshot && sessionStore && sessionKey && needsSkillsSnapshot) {
-            const current = sessionEntry ?? {
-                sessionId,
-                updatedAt: Date.now(),
-            };
-            const next = {
-                ...current,
-                sessionId,
-                updatedAt: Date.now(),
-                skillsSnapshot,
-            };
-            await persistSessionEntry({
-                sessionStore,
-                sessionKey,
-                storePath,
-                entry: next,
-            });
-            sessionEntry = next;
-        }
-        // Persist explicit /command overrides to the session store when we have a key.
-        if (sessionStore && sessionKey) {
-            const entry = sessionStore[sessionKey] ??
-                sessionEntry ?? { sessionId, updatedAt: Date.now() };
-            const next = { ...entry, sessionId, updatedAt: Date.now() };
-            if (thinkOverride) {
-                next.thinkingLevel = thinkOverride;
-            }
-            applyVerboseOverride(next, verboseOverride);
-            await persistSessionEntry({
-                sessionStore,
-                sessionKey,
-                storePath,
-                entry: next,
-            });
-            sessionEntry = next;
-        }
-        const agentModelPrimary = resolveAgentModelPrimary(cfg, sessionAgentId);
-        const cfgForModelSelection = agentModelPrimary
-            ? {
-                ...cfg,
-                agents: {
-                    ...cfg.agents,
-                    defaults: {
-                        ...cfg.agents?.defaults,
-                        model: {
-                            ...(typeof cfg.agents?.defaults?.model === "object"
-                                ? cfg.agents.defaults.model
-                                : undefined),
-                            primary: agentModelPrimary,
-                        },
-                    },
-                },
-            }
-            : cfg;
-        const configuredDefaultRef = resolveConfiguredModelRef({
-            cfg: cfgForModelSelection,
-            defaultProvider: DEFAULT_PROVIDER,
-            defaultModel: DEFAULT_MODEL,
-        });
-        const { provider: defaultProvider, model: defaultModel } = normalizeModelRef(configuredDefaultRef.provider, configuredDefaultRef.model);
-        let provider = defaultProvider;
-        let model = defaultModel;
-        const hasAllowlist = agentCfg?.models && Object.keys(agentCfg.models).length > 0;
-        const hasStoredOverride = Boolean(sessionEntry?.modelOverride || sessionEntry?.providerOverride);
-        const needsModelCatalog = hasAllowlist || hasStoredOverride;
-        let allowedModelKeys = new Set();
-        let allowedModelCatalog = [];
-        let modelCatalog = null;
-        if (needsModelCatalog) {
-            modelCatalog = await loadModelCatalog({ config: cfg });
-            const allowed = buildAllowedModelSet({
-                cfg,
-                catalog: modelCatalog,
-                defaultProvider,
-                defaultModel,
-            });
-            allowedModelKeys = allowed.allowedKeys;
-            allowedModelCatalog = allowed.allowedCatalog;
-        }
-        if (sessionEntry && sessionStore && sessionKey && hasStoredOverride) {
-            const entry = sessionEntry;
-            const overrideProvider = sessionEntry.providerOverride?.trim() || defaultProvider;
-            const overrideModel = sessionEntry.modelOverride?.trim();
-            if (overrideModel) {
-                const normalizedOverride = normalizeModelRef(overrideProvider, overrideModel);
-                const key = modelKey(normalizedOverride.provider, normalizedOverride.model);
-                if (!isCliProvider(normalizedOverride.provider, cfg) &&
-                    allowedModelKeys.size > 0 &&
-                    !allowedModelKeys.has(key)) {
-                    const { updated } = applyModelOverrideToSessionEntry({
-                        entry,
-                        selection: { provider: defaultProvider, model: defaultModel, isDefault: true },
-                    });
-                    if (updated) {
-                        await persistSessionEntry({
-                            sessionStore,
-                            sessionKey,
-                            storePath,
-                            entry,
-                        });
-                    }
-                }
-            }
-        }
-        const storedProviderOverride = sessionEntry?.providerOverride?.trim();
-        const storedModelOverride = sessionEntry?.modelOverride?.trim();
-        if (storedModelOverride) {
-            const candidateProvider = storedProviderOverride || defaultProvider;
-            const normalizedStored = normalizeModelRef(candidateProvider, storedModelOverride);
-            const key = modelKey(normalizedStored.provider, normalizedStored.model);
-            if (isCliProvider(normalizedStored.provider, cfg) ||
-                allowedModelKeys.size === 0 ||
-                allowedModelKeys.has(key)) {
-                provider = normalizedStored.provider;
-                model = normalizedStored.model;
-            }
-        }
-        if (sessionEntry) {
-            const authProfileId = sessionEntry.authProfileOverride;
-            if (authProfileId) {
-                const entry = sessionEntry;
-                const store = ensureAuthProfileStore();
-                const profile = store.profiles[authProfileId];
-                if (!profile || profile.provider !== provider) {
-                    if (sessionStore && sessionKey) {
-                        await clearSessionAuthProfileOverride({
-                            sessionEntry: entry,
-                            sessionStore,
-                            sessionKey,
-                            storePath,
-                        });
-                    }
-                }
-            }
-        }
-        if (!resolvedThinkLevel) {
-            let catalogForThinking = modelCatalog ?? allowedModelCatalog;
-            if (!catalogForThinking || catalogForThinking.length === 0) {
-                modelCatalog = await loadModelCatalog({ config: cfg });
-                catalogForThinking = modelCatalog;
-            }
-            resolvedThinkLevel = resolveThinkingDefault({
-                cfg,
-                provider,
-                model,
-                catalog: catalogForThinking,
-            });
-        }
-        if (resolvedThinkLevel === "xhigh" && !supportsXHighThinking(provider, model)) {
-            const explicitThink = Boolean(thinkOnce || thinkOverride);
-            if (explicitThink) {
-                throw new Error(`Thinking level "xhigh" is only supported for ${formatXHighModelHint()}.`);
-            }
-            resolvedThinkLevel = "high";
-            if (sessionEntry && sessionStore && sessionKey && sessionEntry.thinkingLevel === "xhigh") {
-                const entry = sessionEntry;
-                entry.thinkingLevel = "high";
-                entry.updatedAt = Date.now();
-                await persistSessionEntry({
-                    sessionStore,
-                    sessionKey,
-                    storePath,
-                    entry,
-                });
-            }
-        }
-        let sessionFile = resolveSessionFilePath(sessionId, sessionEntry, {
-            agentId: sessionAgentId,
-        });
-        if (sessionStore && sessionKey) {
-            const threadIdFromSessionKey = parseSessionThreadInfo(sessionKey).threadId;
-            const fallbackSessionFile = !sessionEntry?.sessionFile
-                ? resolveSessionTranscriptPath(sessionId, sessionAgentId, opts.threadId ?? threadIdFromSessionKey)
-                : undefined;
-            const resolvedSessionFile = await resolveAndPersistSessionFile({
-                sessionId,
-                sessionKey,
-                sessionStore,
-                storePath,
-                sessionEntry,
-                agentId: sessionAgentId,
-                sessionsDir: path.dirname(storePath),
-                fallbackSessionFile,
-            });
-            sessionFile = resolvedSessionFile.sessionFile;
-            sessionEntry = resolvedSessionFile.sessionEntry;
-        }
-        const startedAt = Date.now();
-        let lifecycleEnded = false;
-        let result;
-        let fallbackProvider = provider;
-        let fallbackModel = model;
-        try {
-            const runContext = resolveAgentRunContext(opts);
-            const messageChannel = resolveMessageChannel(runContext.messageChannel, opts.replyChannel ?? opts.channel);
-            const spawnedBy = opts.spawnedBy ?? sessionEntry?.spawnedBy;
-            // Keep fallback candidate resolution centralized so session model overrides,
-            // per-agent overrides, and default fallbacks stay consistent across callers.
-            const effectiveFallbacksOverride = resolveEffectiveModelFallbacks({
-                cfg,
-                agentId: sessionAgentId,
-                hasSessionModelOverride: Boolean(storedModelOverride),
-            });
-            // Track model fallback attempts so retries on an existing session don't
-            // re-inject the original prompt as a duplicate user message.
-            let fallbackAttemptIndex = 0;
-            const fallbackResult = await runWithModelFallback({
-                cfg,
-                provider,
-                model,
-                agentDir,
-                fallbacksOverride: effectiveFallbacksOverride,
-                run: (providerOverride, modelOverride) => {
-                    const isFallbackRetry = fallbackAttemptIndex > 0;
-                    fallbackAttemptIndex += 1;
-                    return runAgentAttempt({
-                        providerOverride,
-                        modelOverride,
-                        cfg,
-                        sessionEntry,
-                        sessionId,
-                        sessionKey,
-                        sessionAgentId,
-                        sessionFile,
-                        workspaceDir,
-                        body,
-                        isFallbackRetry,
-                        resolvedThinkLevel,
-                        timeoutMs,
-                        runId,
-                        opts,
-                        runContext,
-                        spawnedBy,
-                        messageChannel,
-                        skillsSnapshot,
-                        resolvedVerboseLevel,
-                        agentDir,
-                        primaryProvider: provider,
-                        onAgentEvent: (evt) => {
-                            // Track lifecycle end for fallback emission below.
-                            if (evt.stream === "lifecycle" &&
-                                typeof evt.data?.phase === "string" &&
-                                (evt.data.phase === "end" || evt.data.phase === "error")) {
-                                lifecycleEnded = true;
-                            }
-                        },
-                    });
-                },
-            });
-            result = fallbackResult.result;
-            fallbackProvider = fallbackResult.provider;
-            fallbackModel = fallbackResult.model;
-            if (!lifecycleEnded) {
-                emitAgentEvent({
-                    runId,
-                    stream: "lifecycle",
-                    data: {
-                        phase: "end",
-                        startedAt,
-                        endedAt: Date.now(),
-                        aborted: result.meta.aborted ?? false,
-                    },
-                });
-            }
-        }
-        catch (err) {
-            if (!lifecycleEnded) {
-                emitAgentEvent({
-                    runId,
-                    stream: "lifecycle",
-                    data: {
-                        phase: "error",
-                        startedAt,
-                        endedAt: Date.now(),
-                        error: String(err),
-                    },
-                });
-            }
-            throw err;
-        }
-        // Update token+model fields in the session store.
-        if (sessionStore && sessionKey) {
-            await updateSessionStoreAfterAgentRun({
-                cfg,
-                contextTokensOverride: agentCfg?.contextTokens,
-                sessionId,
-                sessionKey,
-                storePath,
-                sessionStore,
-                defaultProvider: provider,
-                defaultModel: model,
-                fallbackProvider,
-                fallbackModel,
-                result,
-            });
-        }
-        const payloads = result.payloads ?? [];
-        return await deliverAgentCommandResult({
-            cfg,
-            deps,
-            runtime,
-            opts,
-            sessionEntry,
-            result,
-            payloads,
-        });
-    }
-    finally {
-        clearAgentRunContext(runId);
-    }
-}

package/dist/commands/agents.bindings.js

@@ -1,133 +0,0 @@
-import { resolveChannelDefaultAccountId } from "../channels/plugins/helpers.js";
-import { getChannelPlugin, normalizeChannelId } from "../channels/plugins/index.js";
-import { DEFAULT_ACCOUNT_ID, normalizeAgentId } from "../routing/session-key.js";
-function bindingMatchKey(match) {
-    const accountId = match.accountId?.trim() || DEFAULT_ACCOUNT_ID;
-    return [
-        match.channel,
-        accountId,
-        match.peer?.kind ?? "",
-        match.peer?.id ?? "",
-        match.guildId ?? "",
-        match.teamId ?? "",
-    ].join("|");
-}
-export function describeBinding(binding) {
-    const match = binding.match;
-    const parts = [match.channel];
-    if (match.accountId) {
-        parts.push(`accountId=${match.accountId}`);
-    }
-    if (match.peer) {
-        parts.push(`peer=${match.peer.kind}:${match.peer.id}`);
-    }
-    if (match.guildId) {
-        parts.push(`guild=${match.guildId}`);
-    }
-    if (match.teamId) {
-        parts.push(`team=${match.teamId}`);
-    }
-    return parts.join(" ");
-}
-export function applyAgentBindings(cfg, bindings) {
-    const existing = cfg.bindings ?? [];
-    const existingMatchMap = new Map();
-    for (const binding of existing) {
-        const key = bindingMatchKey(binding.match);
-        if (!existingMatchMap.has(key)) {
-            existingMatchMap.set(key, normalizeAgentId(binding.agentId));
-        }
-    }
-    const added = [];
-    const skipped = [];
-    const conflicts = [];
-    for (const binding of bindings) {
-        const agentId = normalizeAgentId(binding.agentId);
-        const key = bindingMatchKey(binding.match);
-        const existingAgentId = existingMatchMap.get(key);
-        if (existingAgentId) {
-            if (existingAgentId === agentId) {
-                skipped.push(binding);
-            }
-            else {
-                conflicts.push({ binding, existingAgentId });
-            }
-            continue;
-        }
-        existingMatchMap.set(key, agentId);
-        added.push({ ...binding, agentId });
-    }
-    if (added.length === 0) {
-        return { config: cfg, added, skipped, conflicts };
-    }
-    return {
-        config: {
-            ...cfg,
-            bindings: [...existing, ...added],
-        },
-        added,
-        skipped,
-        conflicts,
-    };
-}
-function resolveDefaultAccountId(cfg, provider) {
-    const plugin = getChannelPlugin(provider);
-    if (!plugin) {
-        return DEFAULT_ACCOUNT_ID;
-    }
-    return resolveChannelDefaultAccountId({ plugin, cfg });
-}
-export function buildChannelBindings(params) {
-    const bindings = [];
-    const agentId = normalizeAgentId(params.agentId);
-    for (const channel of params.selection) {
-        const match = { channel };
-        const accountId = params.accountIds?.[channel]?.trim();
-        if (accountId) {
-            match.accountId = accountId;
-        }
-        else {
-            const plugin = getChannelPlugin(channel);
-            if (plugin?.meta.forceAccountBinding) {
-                match.accountId = resolveDefaultAccountId(params.config, channel);
-            }
-        }
-        bindings.push({ agentId, match });
-    }
-    return bindings;
-}
-export function parseBindingSpecs(params) {
-    const bindings = [];
-    const errors = [];
-    const specs = params.specs ?? [];
-    const agentId = normalizeAgentId(params.agentId);
-    for (const raw of specs) {
-        const trimmed = raw?.trim();
-        if (!trimmed) {
-            continue;
-        }
-        const [channelRaw, accountRaw] = trimmed.split(":", 2);
-        const channel = normalizeChannelId(channelRaw);
-        if (!channel) {
-            errors.push(`Unknown channel "${channelRaw}".`);
-            continue;
-        }
-        let accountId = accountRaw?.trim();
-        if (accountRaw !== undefined && !accountId) {
-            errors.push(`Invalid binding "${trimmed}" (empty account id).`);
-            continue;
-        }
-        if (!accountId) {
-            const plugin = getChannelPlugin(channel);
-            if (plugin?.meta.forceAccountBinding) {
-                accountId = resolveDefaultAccountId(params.config, channel);
-            }
-        }
-        const match = { channel };
-        if (accountId) {
-            match.accountId = accountId;
-        }
-        bindings.push({ agentId, match });
-    }
-    return { bindings, errors };
-}

package/dist/commands/agents.command-shared.js

@@ -1,18 +0,0 @@
-import { formatCliCommand } from "../cli/command-format.js";
-import { readConfigFileSnapshot } from "../config/config.js";
-export function createQuietRuntime(runtime) {
-    return { ...runtime, log: () => { } };
-}
-export async function requireValidConfig(runtime) {
-    const snapshot = await readConfigFileSnapshot();
-    if (snapshot.exists && !snapshot.valid) {
-        const issues = snapshot.issues.length > 0
-            ? snapshot.issues.map((issue) => `- ${issue.path}: ${issue.message}`).join("\n")
-            : "Unknown validation issue.";
-        runtime.error(`Config invalid:\n${issues}`);
-        runtime.error(`Fix the config or run ${formatCliCommand("poolbot doctor")}.`);
-        runtime.exit(1);
-        return null;
-    }
-    return snapshot.config;
-}