@spinabot/brigade 1.3.2 → 1.4.0

package/dist/agents/channels/bundled-channel-metas.js

@@ -0,0 +1,44 @@
+/**
+ * Built-in channel metas — the single source of truth for the bundled
+ * channels' user-facing metadata (`ChannelMeta`).
+ *
+ * This module is DELIBERATELY import-light: it pulls in nothing but the
+ * `ChannelMeta` type, so the channel-meta registry (and through it, the
+ * system-prompt markdown gate + the exposure resolver) can read bundled
+ * channel metadata WITHOUT eagerly loading the channel adapters (Baileys
+ * sockets, the Telegram bot runtime). The plugins import THESE constants for
+ * their `meta` field, so there is exactly one definition per channel.
+ *
+ * Canonical channel ids are inlined as literals here — they are stable
+ * constants (`"whatsapp"`, `"telegram"`) and re-importing them from each
+ * channel's `account-config` module would risk dragging adapter-adjacent code
+ * into this light module. The plugin's own `WHATSAPP_CHANNEL_ID` /
+ * `TELEGRAM_CHANNEL_ID` literals must stay in sync with the `id` fields below;
+ * they are the same string by construction.
+ */
+/** WhatsApp channel metadata (markdown-capable; visible everywhere by default). */
+export const WHATSAPP_CHANNEL_META = {
+    id: "whatsapp",
+    label: "WhatsApp",
+    selectionLabel: "WhatsApp",
+    docsPath: "channels/whatsapp",
+    blurb: "QR-pair a phone, DM/group chat over WhatsApp Web.",
+    order: 10,
+    markdownCapable: true,
+};
+/** Telegram channel metadata (markdown-capable; visible everywhere by default). */
+export const TELEGRAM_CHANNEL_META = {
+    id: "telegram",
+    label: "Telegram",
+    selectionLabel: "Telegram",
+    docsPath: "channels/telegram",
+    blurb: "Paste a @BotFather token, DM/group chat over a Telegram bot.",
+    order: 20,
+    markdownCapable: true,
+};
+/** Every bundled channel meta, in declaration order. The registry seeds from this. */
+export const BUNDLED_CHANNEL_METAS = [
+    WHATSAPP_CHANNEL_META,
+    TELEGRAM_CHANNEL_META,
+];
+//# sourceMappingURL=bundled-channel-metas.js.map

package/dist/agents/channels/bundled-channel-metas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundled-channel-metas.js","sourceRoot":"","sources":["../../../src/agents/channels/bundled-channel-metas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,mFAAmF;AACnF,MAAM,CAAC,MAAM,qBAAqB,GAAgB;IACjD,EAAE,EAAE,UAAU;IACd,KAAK,EAAE,UAAU;IACjB,cAAc,EAAE,UAAU;IAC1B,QAAQ,EAAE,mBAAmB;IAC7B,KAAK,EAAE,mDAAmD;IAC1D,KAAK,EAAE,EAAE;IACT,eAAe,EAAE,IAAI;CACrB,CAAC;AAEF,mFAAmF;AACnF,MAAM,CAAC,MAAM,qBAAqB,GAAgB;IACjD,EAAE,EAAE,UAAU;IACd,KAAK,EAAE,UAAU;IACjB,cAAc,EAAE,UAAU;IAC1B,QAAQ,EAAE,mBAAmB;IAC7B,KAAK,EAAE,8DAA8D;IACrE,KAAK,EAAE,EAAE;IACT,eAAe,EAAE,IAAI;CACrB,CAAC;AAEF,sFAAsF;AACtF,MAAM,CAAC,MAAM,qBAAqB,GAA2B;IAC5D,qBAAqB;IACrB,qBAAqB;CACrB,CAAC"}

package/dist/agents/channels/channel-messaging-registry.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Channel-messaging registry — the process-wide lookup behind "how do I
+ * canonicalise / resolve an OUTBOUND target for channel <id>?".
+ *
+ * Mirrors the `channel-meta-registry.ts` pattern (FIX #9): a dynamic
+ * registration seam keyed by lowercased channel id, resolved through one
+ * process-global singleton so a hot reload (or CLI + gateway in one process)
+ * shares a single slot.
+ *
+ * WHY A REGISTRY (and not "reach into the plugin off the manager"): the
+ * `send_message` tool runs against the LEGACY `ChannelManager`
+ * (`agents/channels/manager.ts`), which hands back a runtime `ChannelAdapter`
+ * via `adapter(id)` and deliberately exposes NO `ChannelPlugin` (the plugins
+ * live behind the multi-account plugin manager + `core/server.ts`). Pulling a
+ * channel plugin module into the send path would also eagerly load its adapter
+ * (Baileys sockets, the Telegram bot runtime). So instead the plugin engine
+ * registers JUST the plugin's `messaging` adapter here — plain function
+ * references, import-light — and the send tool consults this registry.
+ *
+ * A channel with NO `messaging` adapter simply never registers; the send tool's
+ * `resolveOutboundTarget` then returns the raw `to` unchanged, so back-compat
+ * is preserved by construction.
+ */
+import type { ChannelMessagingAdapter } from "./types.adapters.js";
+/**
+ * Register (or replace) a channel's OUTBOUND messaging adapter. The plugin
+ * engine calls this when a channel module that declares `plugin.messaging`
+ * registers, so the `send_message` tool can address by name/handle/explicit
+ * target. Last registration per id wins. No-ops on an empty/unusable id.
+ */
+export declare function registerChannelMessagingAdapter(channelId: string | null | undefined, adapter: ChannelMessagingAdapter): void;
+/**
+ * Bulk-register every messaging adapter declared on a plugin list (skipping
+ * plugins that omit the slot). The gateway bootstrap calls this once with its
+ * `bundledChannelPlugins` — parallel to how it seeds the meta registry — so the
+ * send tool can address by name/handle for any channel that opts in. Plugins
+ * WITHOUT a `messaging` adapter are simply skipped, leaving raw-id passthrough.
+ */
+export declare function syncChannelMessagingAdaptersFromPlugins(plugins: ReadonlyArray<{
+    id: string;
+    messaging?: ChannelMessagingAdapter;
+}>): void;
+/**
+ * Drop every dynamically-registered messaging adapter. PUBLIC — the gateway's
+ * `stopExtensions()` calls this during a `system.reload` teardown so the
+ * registry starts clean and `startExtensions()` re-syncs ONLY the currently-
+ * loaded channels (the sync seam is `.set()`-only and never removes a slot, so
+ * without this an edited/removed channel's messaging adapter would leak across
+ * the reload and keep rewriting outbound targets). Idempotent.
+ */
+export declare function clearChannelMessagingRegistry(): void;
+/** Test-only alias of {@link clearChannelMessagingRegistry}. Kept so existing tests don't break. */
+export declare function resetChannelMessagingRegistryForTests(): void;
+/**
+ * Look up a channel's registered OUTBOUND messaging adapter by id (or alias the
+ * caller already normalized). Returns `undefined` when the channel registered
+ * none — the caller then falls back to raw-id behaviour. Case-insensitive.
+ */
+export declare function getChannelMessagingAdapter(channelId: string | null | undefined): ChannelMessagingAdapter | undefined;
+/** Outcome of {@link resolveOutboundTarget}. */
+export type ResolvedOutboundTarget = {
+    /**
+     * The concrete target id to hand `ChannelAdapter.sendText`. When no
+     * messaging adapter is registered (or it couldn't improve on the input),
+     * this is the caller's raw `to`, byte-for-byte.
+     */
+    to: string;
+    /**
+     * A different channel id the explicit form re-targeted to (e.g. the agent
+     * passed `telegram:123` while sending through whatsapp). `undefined` when
+     * the target stays on the same channel. The caller decides whether to honor
+     * a cross-channel hop (owner gate) — this helper only surfaces it.
+     */
+    channelId?: string;
+    /** Whether a messaging adapter actually participated (for logging/tests). */
+    usedAdapter: boolean;
+    /** Whether the optional `targetResolver` resolved a human name → id. */
+    resolvedByName: boolean;
+};
+/**
+ * Heuristic: does this `to` look like a human NAME / handle rather than an
+ * already-concrete conversation id? Concrete ids carry channel-shape markers
+ * (a `:` scheme, an `@` domain like `…@s.whatsapp.net`, a leading `+`, or are
+ * all-digits). A bare word / `@handle` is treated as a name worth resolving.
+ * Deliberately conservative — when unsure we DON'T treat it as a name, so we
+ * never send a resolver a value that's plainly an id.
+ */
+export declare function looksLikeContactName(to: string): boolean;
+/**
+ * Turn the agent's loose `to` into a concrete outbound target for `channelId`,
+ * using that channel's registered `messaging` adapter when present. The order
+ * matches the `ChannelMessagingAdapter` contract:
+ *
+ *   1. No adapter registered → return the raw `to` UNCHANGED (back-compat).
+ *   2. `parseExplicitTarget(to)` — honor an explicit `scheme:value` / `@handle`
+ *      form (and surface any cross-channel id it named).
+ *   3. If we're still holding a NAME (not an explicit target) and the adapter
+ *      ships a `targetResolver`, resolve name → id; on a null/throw result fall
+ *      back to the name as-is.
+ *   4. `normalizeTarget(...)` — canonicalise the final target id.
+ *
+ * NEVER throws: a misbehaving adapter (parse/normalize/resolve throwing) is
+ * caught and degrades to the raw `to`, so a buggy channel can't break sends.
+ */
+export declare function resolveOutboundTarget(params: {
+    channelId: string;
+    to: string;
+}): Promise<ResolvedOutboundTarget>;
+/**
+ * Canonicalise an INCOMING peer id to a stable conversation/session identity
+ * using the channel's registered `messaging` adapter when it ships the optional
+ * `resolveInboundConversation` hook (the inverse of the outbound `targetResolver`).
+ * The inbound pipeline calls this just before the 8-tier route resolver so a
+ * name-addressed inbound collapses onto the SAME conversation/session the
+ * outbound side targets.
+ *
+ * Contract — mirrors {@link resolveOutboundTarget}, conservative by construction:
+ *   1. No messaging adapter registered, OR it has no `resolveInboundConversation`
+ *      → return the raw `peerId` UNCHANGED.
+ *   2. The hook returns `null`/empty, OR throws → return the raw `peerId`.
+ *   3. Otherwise → return the canonicalised id.
+ *
+ * NEVER throws. When the result equals the raw `peerId` (the default for any
+ * channel that doesn't opt in), downstream routing is byte-identical to today.
+ */
+export declare function resolveInboundConversation(params: {
+    channelId: string;
+    peerId: string;
+}): string;
+//# sourceMappingURL=channel-messaging-registry.d.ts.map

package/dist/agents/channels/channel-messaging-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel-messaging-registry.d.ts","sourceRoot":"","sources":["../../../src/agents/channels/channel-messaging-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAIH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAkBnE;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAC9C,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACpC,OAAO,EAAE,uBAAuB,GAC9B,IAAI,CAIN;AAED;;;;;;GAMG;AACH,wBAAgB,uCAAuC,CACtD,OAAO,EAAE,aAAa,CAAC;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,uBAAuB,CAAA;CAAE,CAAC,GACzE,IAAI,CAIN;AAED;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,IAAI,IAAI,CAEpD;AAED,oGAAoG;AACpG,wBAAgB,qCAAqC,IAAI,IAAI,CAE5D;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CACzC,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAClC,uBAAuB,GAAG,SAAS,CAIrC;AAMD,gDAAgD;AAChD,MAAM,MAAM,sBAAsB,GAAG;IACpC;;;;OAIG;IACH,EAAE,EAAE,MAAM,CAAC;IACX;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,6EAA6E;IAC7E,WAAW,EAAE,OAAO,CAAC;IACrB,wEAAwE;IACxE,cAAc,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAWxD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,qBAAqB,CAAC,MAAM,EAAE;IACnD,SAAS,EAAE,MAAM,CAAC;IAClB,EAAE,EAAE,MAAM,CAAC;CACX,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAgDlC;AAMD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE;IAClD,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CACf,GAAG,MAAM,CAiBT"}

package/dist/agents/channels/channel-messaging-registry.js

@@ -0,0 +1,211 @@
+/**
+ * Channel-messaging registry — the process-wide lookup behind "how do I
+ * canonicalise / resolve an OUTBOUND target for channel <id>?".
+ *
+ * Mirrors the `channel-meta-registry.ts` pattern (FIX #9): a dynamic
+ * registration seam keyed by lowercased channel id, resolved through one
+ * process-global singleton so a hot reload (or CLI + gateway in one process)
+ * shares a single slot.
+ *
+ * WHY A REGISTRY (and not "reach into the plugin off the manager"): the
+ * `send_message` tool runs against the LEGACY `ChannelManager`
+ * (`agents/channels/manager.ts`), which hands back a runtime `ChannelAdapter`
+ * via `adapter(id)` and deliberately exposes NO `ChannelPlugin` (the plugins
+ * live behind the multi-account plugin manager + `core/server.ts`). Pulling a
+ * channel plugin module into the send path would also eagerly load its adapter
+ * (Baileys sockets, the Telegram bot runtime). So instead the plugin engine
+ * registers JUST the plugin's `messaging` adapter here — plain function
+ * references, import-light — and the send tool consults this registry.
+ *
+ * A channel with NO `messaging` adapter simply never registers; the send tool's
+ * `resolveOutboundTarget` then returns the raw `to` unchanged, so back-compat
+ * is preserved by construction.
+ */
+import { resolveGlobalSingleton } from "../../shared/global-singleton.js";
+import { normalizeOptionalLowercaseString } from "../../shared/string-coerce.js";
+/** Process-global slot so a hot reload (or CLI+gateway in one process) shares one registry. */
+const REGISTRY_STATE_KEY = Symbol.for("brigade.channelMessagingRegistry.state");
+function createState() {
+    return { byChannelId: new Map() };
+}
+function getState() {
+    return resolveGlobalSingleton(REGISTRY_STATE_KEY, createState);
+}
+/**
+ * Register (or replace) a channel's OUTBOUND messaging adapter. The plugin
+ * engine calls this when a channel module that declares `plugin.messaging`
+ * registers, so the `send_message` tool can address by name/handle/explicit
+ * target. Last registration per id wins. No-ops on an empty/unusable id.
+ */
+export function registerChannelMessagingAdapter(channelId, adapter) {
+    const id = normalizeOptionalLowercaseString(channelId);
+    if (!id)
+        return;
+    getState().byChannelId.set(id, adapter);
+}
+/**
+ * Bulk-register every messaging adapter declared on a plugin list (skipping
+ * plugins that omit the slot). The gateway bootstrap calls this once with its
+ * `bundledChannelPlugins` — parallel to how it seeds the meta registry — so the
+ * send tool can address by name/handle for any channel that opts in. Plugins
+ * WITHOUT a `messaging` adapter are simply skipped, leaving raw-id passthrough.
+ */
+export function syncChannelMessagingAdaptersFromPlugins(plugins) {
+    for (const plugin of plugins) {
+        if (plugin.messaging)
+            registerChannelMessagingAdapter(plugin.id, plugin.messaging);
+    }
+}
+/**
+ * Drop every dynamically-registered messaging adapter. PUBLIC — the gateway's
+ * `stopExtensions()` calls this during a `system.reload` teardown so the
+ * registry starts clean and `startExtensions()` re-syncs ONLY the currently-
+ * loaded channels (the sync seam is `.set()`-only and never removes a slot, so
+ * without this an edited/removed channel's messaging adapter would leak across
+ * the reload and keep rewriting outbound targets). Idempotent.
+ */
+export function clearChannelMessagingRegistry() {
+    getState().byChannelId.clear();
+}
+/** Test-only alias of {@link clearChannelMessagingRegistry}. Kept so existing tests don't break. */
+export function resetChannelMessagingRegistryForTests() {
+    clearChannelMessagingRegistry();
+}
+/**
+ * Look up a channel's registered OUTBOUND messaging adapter by id (or alias the
+ * caller already normalized). Returns `undefined` when the channel registered
+ * none — the caller then falls back to raw-id behaviour. Case-insensitive.
+ */
+export function getChannelMessagingAdapter(channelId) {
+    const key = normalizeOptionalLowercaseString(channelId);
+    if (!key)
+        return undefined;
+    return getState().byChannelId.get(key);
+}
+/**
+ * Heuristic: does this `to` look like a human NAME / handle rather than an
+ * already-concrete conversation id? Concrete ids carry channel-shape markers
+ * (a `:` scheme, an `@` domain like `…@s.whatsapp.net`, a leading `+`, or are
+ * all-digits). A bare word / `@handle` is treated as a name worth resolving.
+ * Deliberately conservative — when unsure we DON'T treat it as a name, so we
+ * never send a resolver a value that's plainly an id.
+ */
+export function looksLikeContactName(to) {
+    const t = to.trim();
+    if (t.length === 0)
+        return false;
+    // `scheme:value` (telegram:123) — explicit id form, not a name.
+    if (/^[a-z][a-z0-9_-]*:/i.test(t))
+        return false;
+    // `user@domain` JID (14057144199@s.whatsapp.net) — an id, not a name.
+    if (/@[^@\s]+\.[^@\s]+$/.test(t))
+        return false;
+    // Phone-ish (+15551234567 / 15551234567) — an id, not a name.
+    if (/^\+?\d[\d\s().-]{4,}$/.test(t))
+        return false;
+    // `@handle` OR a plain word/words → treat as a name worth resolving.
+    return true;
+}
+/**
+ * Turn the agent's loose `to` into a concrete outbound target for `channelId`,
+ * using that channel's registered `messaging` adapter when present. The order
+ * matches the `ChannelMessagingAdapter` contract:
+ *
+ *   1. No adapter registered → return the raw `to` UNCHANGED (back-compat).
+ *   2. `parseExplicitTarget(to)` — honor an explicit `scheme:value` / `@handle`
+ *      form (and surface any cross-channel id it named).
+ *   3. If we're still holding a NAME (not an explicit target) and the adapter
+ *      ships a `targetResolver`, resolve name → id; on a null/throw result fall
+ *      back to the name as-is.
+ *   4. `normalizeTarget(...)` — canonicalise the final target id.
+ *
+ * NEVER throws: a misbehaving adapter (parse/normalize/resolve throwing) is
+ * caught and degrades to the raw `to`, so a buggy channel can't break sends.
+ */
+export async function resolveOutboundTarget(params) {
+    const { channelId, to } = params;
+    const adapter = getChannelMessagingAdapter(channelId);
+    // (1) No messaging adapter → raw-id passthrough, byte-for-byte.
+    if (!adapter) {
+        return { to, usedAdapter: false, resolvedByName: false };
+    }
+    try {
+        let target = to;
+        let crossChannelId;
+        let isExplicit = false;
+        // (2) Explicit-target form?
+        const parsed = adapter.parseExplicitTarget(to);
+        if (parsed) {
+            isExplicit = true;
+            target = parsed.target;
+            if (parsed.channelId)
+                crossChannelId = parsed.channelId;
+        }
+        // (3) Name → id resolution (only when NOT an explicit target, the input
+        //     reads like a name, and the channel ships a resolver).
+        let resolvedByName = false;
+        if (!isExplicit && typeof adapter.targetResolver === "function" && looksLikeContactName(target)) {
+            const resolved = await adapter.targetResolver(target);
+            if (resolved != null && resolved !== "") {
+                target = resolved;
+                resolvedByName = true;
+            }
+            // null/empty → fall through with the name unchanged (caller may still
+            // send to it verbatim, matching the no-resolver path).
+        }
+        // (4) Canonicalise.
+        const normalized = adapter.normalizeTarget(target);
+        const finalTo = normalized && normalized.length > 0 ? normalized : target;
+        return {
+            to: finalTo,
+            ...(crossChannelId ? { channelId: crossChannelId } : {}),
+            usedAdapter: true,
+            resolvedByName,
+        };
+    }
+    catch {
+        // A misbehaving adapter must never break sends — degrade to the raw id.
+        return { to, usedAdapter: false, resolvedByName: false };
+    }
+}
+/* -------------------------------------------------------------------------
+ * Default inbound-conversation resolution (the inverse of resolveOutboundTarget)
+ * --------------------------------------------------------------------- */
+/**
+ * Canonicalise an INCOMING peer id to a stable conversation/session identity
+ * using the channel's registered `messaging` adapter when it ships the optional
+ * `resolveInboundConversation` hook (the inverse of the outbound `targetResolver`).
+ * The inbound pipeline calls this just before the 8-tier route resolver so a
+ * name-addressed inbound collapses onto the SAME conversation/session the
+ * outbound side targets.
+ *
+ * Contract — mirrors {@link resolveOutboundTarget}, conservative by construction:
+ *   1. No messaging adapter registered, OR it has no `resolveInboundConversation`
+ *      → return the raw `peerId` UNCHANGED.
+ *   2. The hook returns `null`/empty, OR throws → return the raw `peerId`.
+ *   3. Otherwise → return the canonicalised id.
+ *
+ * NEVER throws. When the result equals the raw `peerId` (the default for any
+ * channel that doesn't opt in), downstream routing is byte-identical to today.
+ */
+export function resolveInboundConversation(params) {
+    const { channelId, peerId } = params;
+    const adapter = getChannelMessagingAdapter(channelId);
+    // (1) No adapter / no inbound hook → raw peer id, byte-for-byte.
+    if (!adapter || typeof adapter.resolveInboundConversation !== "function") {
+        return peerId;
+    }
+    try {
+        const resolved = adapter.resolveInboundConversation(peerId);
+        // (2) null / empty → keep the raw peer id (no behaviour change).
+        if (resolved == null || resolved === "")
+            return peerId;
+        // (3) canonicalised id.
+        return resolved;
+    }
+    catch {
+        // A misbehaving adapter must never break inbound routing — degrade.
+        return peerId;
+    }
+}
+//# sourceMappingURL=channel-messaging-registry.js.map

package/dist/agents/channels/channel-messaging-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel-messaging-registry.js","sourceRoot":"","sources":["../../../src/agents/channels/channel-messaging-registry.ts"],"names":[],"mappings":"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"}

package/dist/agents/channels/channel-meta-registry.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Channel-meta registry — the process-wide lookup behind "what does channel
+ * <id> declare about itself?" (markdown capability, exposure, aliases, …).
+ *
+ * Brand-scrubbed analogue of upstream's `src/channels/registry.ts` +
+ * `src/channels/chat-meta.ts` two-tier lookup, collapsed to the slice Brigade
+ * needs: a built-in catalog of the bundled channels' metas, plus a dynamic
+ * registration seam for channels that register through the plugin engine.
+ *
+ * WHY A REGISTRY (and not "just read `bundledChannelPlugins`"): the gateway's
+ * `bundledChannelPlugins` list (`core/server.ts`) is only populated for the
+ * MULTI-ACCOUNT plugin path, and pulling a channel plugin module into the
+ * system-prompt layer would eagerly load its adapter (Baileys sockets, the
+ * Telegram bot runtime, …). This module is import-light on purpose: the
+ * built-in metas are plain data constants (see `bundled-channel-metas.ts`),
+ * so the markdown gate + exposure resolver can consult channel metadata from
+ * anywhere — including the system-prompt assembly — without dragging the
+ * runtime in.
+ *
+ * Lookup order (mirrors upstream's built-in-then-plugin precedence):
+ *   1. Dynamically-registered plugin metas (last registration wins per id).
+ *   2. The built-in bundled catalog (WhatsApp, Telegram).
+ *
+ * Ids and aliases are matched case-insensitively. Unknown ids return
+ * `undefined` so callers can apply their own default (the markdown gate
+ * deliberately defaults markdown ON for unknown channels — see
+ * `isMarkdownCapableChannel`).
+ */
+import type { ChannelMeta } from "./types.core.js";
+/**
+ * Register (or replace) a channel's meta at runtime. The plugin engine calls
+ * this when a channel module registers, so external / future channels surface
+ * in the same lookups as the bundled ones. Last registration per id wins.
+ * No-ops on a meta without a usable id.
+ */
+export declare function registerChannelMeta(meta: ChannelMeta): void;
+/**
+ * Drop every dynamically-registered meta (the built-in catalog is untouched).
+ * PUBLIC — the gateway's `stopExtensions()` calls this during a `system.reload`
+ * teardown so the registry starts clean and the next `startExtensions()` re-
+ * registers ONLY the currently-loaded channels (registration is `.set()`-only
+ * and never removes, so without this a removed channel's meta would leak across
+ * the reload). Idempotent.
+ */
+export declare function clearChannelMetaRegistry(): void;
+/** Test-only alias of {@link clearChannelMetaRegistry}. Kept so existing tests don't break. */
+export declare function resetChannelMetaRegistryForTests(): void;
+/**
+ * Look up a registered channel plugin's full `ChannelMeta` by id or alias.
+ * Returns `undefined` for an unknown channel. Case-insensitive.
+ *
+ * Named to mirror the upstream accessor (`getRegisteredChannelPluginMeta`) so
+ * the parity story is legible; `getChatChannelMeta` is the friendlier alias.
+ */
+export declare function getRegisteredChannelPluginMeta(channelId: string | null | undefined): ChannelMeta | undefined;
+/** Friendlier alias for {@link getRegisteredChannelPluginMeta}. */
+export declare function getChatChannelMeta(channelId: string | null | undefined): ChannelMeta | undefined;
+/** Every channel meta currently known (built-in + dynamic), de-duplicated by id. */
+export declare function listChannelMetas(): ChannelMeta[];
+//# sourceMappingURL=channel-meta-registry.d.ts.map

package/dist/agents/channels/channel-meta-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel-meta-registry.d.ts","sourceRoot":"","sources":["../../../src/agents/channels/channel-meta-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAKH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAkBnD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAI3D;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,IAAI,IAAI,CAE/C;AAED,+FAA+F;AAC/F,wBAAgB,gCAAgC,IAAI,IAAI,CAEvD;AAyBD;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS,CAI5G;AAED,mEAAmE;AACnE,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS,CAEhG;AAED,oFAAoF;AACpF,wBAAgB,gBAAgB,IAAI,WAAW,EAAE,CAahD"}

package/dist/agents/channels/channel-meta-registry.js

@@ -0,0 +1,128 @@
+/**
+ * Channel-meta registry — the process-wide lookup behind "what does channel
+ * <id> declare about itself?" (markdown capability, exposure, aliases, …).
+ *
+ * Brand-scrubbed analogue of upstream's `src/channels/registry.ts` +
+ * `src/channels/chat-meta.ts` two-tier lookup, collapsed to the slice Brigade
+ * needs: a built-in catalog of the bundled channels' metas, plus a dynamic
+ * registration seam for channels that register through the plugin engine.
+ *
+ * WHY A REGISTRY (and not "just read `bundledChannelPlugins`"): the gateway's
+ * `bundledChannelPlugins` list (`core/server.ts`) is only populated for the
+ * MULTI-ACCOUNT plugin path, and pulling a channel plugin module into the
+ * system-prompt layer would eagerly load its adapter (Baileys sockets, the
+ * Telegram bot runtime, …). This module is import-light on purpose: the
+ * built-in metas are plain data constants (see `bundled-channel-metas.ts`),
+ * so the markdown gate + exposure resolver can consult channel metadata from
+ * anywhere — including the system-prompt assembly — without dragging the
+ * runtime in.
+ *
+ * Lookup order (mirrors upstream's built-in-then-plugin precedence):
+ *   1. Dynamically-registered plugin metas (last registration wins per id).
+ *   2. The built-in bundled catalog (WhatsApp, Telegram).
+ *
+ * Ids and aliases are matched case-insensitively. Unknown ids return
+ * `undefined` so callers can apply their own default (the markdown gate
+ * deliberately defaults markdown ON for unknown channels — see
+ * `isMarkdownCapableChannel`).
+ */
+import { resolveGlobalSingleton } from "../../shared/global-singleton.js";
+import { normalizeOptionalLowercaseString } from "../../shared/string-coerce.js";
+import { BUNDLED_CHANNEL_METAS } from "./bundled-channel-metas.js";
+/** Process-global slot so a hot reload (or CLI+gateway in one process) shares one registry. */
+const REGISTRY_STATE_KEY = Symbol.for("brigade.channelMetaRegistry.state");
+function createState() {
+    return { dynamic: new Map() };
+}
+function getState() {
+    return resolveGlobalSingleton(REGISTRY_STATE_KEY, createState);
+}
+/**
+ * Register (or replace) a channel's meta at runtime. The plugin engine calls
+ * this when a channel module registers, so external / future channels surface
+ * in the same lookups as the bundled ones. Last registration per id wins.
+ * No-ops on a meta without a usable id.
+ */
+export function registerChannelMeta(meta) {
+    const id = normalizeOptionalLowercaseString(meta?.id);
+    if (!id)
+        return;
+    getState().dynamic.set(id, meta);
+}
+/**
+ * Drop every dynamically-registered meta (the built-in catalog is untouched).
+ * PUBLIC — the gateway's `stopExtensions()` calls this during a `system.reload`
+ * teardown so the registry starts clean and the next `startExtensions()` re-
+ * registers ONLY the currently-loaded channels (registration is `.set()`-only
+ * and never removes, so without this a removed channel's meta would leak across
+ * the reload). Idempotent.
+ */
+export function clearChannelMetaRegistry() {
+    getState().dynamic.clear();
+}
+/** Test-only alias of {@link clearChannelMetaRegistry}. Kept so existing tests don't break. */
+export function resetChannelMetaRegistryForTests() {
+    clearChannelMetaRegistry();
+}
+/**
+ * Build the merged lookup map for a single resolution pass: built-in catalog
+ * first, then dynamic registrations layered on top (dynamic wins per id).
+ * Each meta is indexed by its own id AND every declared alias (all lowercased).
+ */
+function buildLookup() {
+    const byKey = new Map();
+    const index = (meta) => {
+        const id = normalizeOptionalLowercaseString(meta.id);
+        if (!id)
+            return;
+        byKey.set(id, meta);
+        for (const alias of meta.aliases ?? []) {
+            const a = normalizeOptionalLowercaseString(alias);
+            if (a)
+                byKey.set(a, meta);
+        }
+    };
+    for (const meta of BUNDLED_CHANNEL_METAS)
+        index(meta);
+    // Dynamic registrations layer on top so an external plugin can override a
+    // bundled channel's meta (and so its id/aliases win on collision).
+    for (const meta of getState().dynamic.values())
+        index(meta);
+    return byKey;
+}
+/**
+ * Look up a registered channel plugin's full `ChannelMeta` by id or alias.
+ * Returns `undefined` for an unknown channel. Case-insensitive.
+ *
+ * Named to mirror the upstream accessor (`getRegisteredChannelPluginMeta`) so
+ * the parity story is legible; `getChatChannelMeta` is the friendlier alias.
+ */
+export function getRegisteredChannelPluginMeta(channelId) {
+    const key = normalizeOptionalLowercaseString(channelId);
+    if (!key)
+        return undefined;
+    return buildLookup().get(key);
+}
+/** Friendlier alias for {@link getRegisteredChannelPluginMeta}. */
+export function getChatChannelMeta(channelId) {
+    return getRegisteredChannelPluginMeta(channelId);
+}
+/** Every channel meta currently known (built-in + dynamic), de-duplicated by id. */
+export function listChannelMetas() {
+    const seen = new Set();
+    const out = [];
+    const push = (meta) => {
+        const id = normalizeOptionalLowercaseString(meta.id);
+        if (!id || seen.has(id))
+            return;
+        seen.add(id);
+        out.push(meta);
+    };
+    // Dynamic first so an override replaces the bundled entry in the output.
+    for (const meta of getState().dynamic.values())
+        push(meta);
+    for (const meta of BUNDLED_CHANNEL_METAS)
+        push(meta);
+    return out;
+}
+//# sourceMappingURL=channel-meta-registry.js.map

package/dist/agents/channels/channel-meta-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel-meta-registry.js","sourceRoot":"","sources":["../../../src/agents/channels/channel-meta-registry.ts"],"names":[],"mappings":"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"}