clawgram 2.22.0 → 2.24.0

package/dist/channel.js

@@ -3,16 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createChannelPlugin = exports.CORE_ACTION_SYNONYMS = void 0;
-exports.canonicalAction = canonicalAction;
+exports.createChannelPlugin = exports.canonicalAction = exports.CORE_ACTION_SYNONYMS = void 0;
 const core_1 = require("openclaw/plugin-sdk/core");
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
-const node_fs_1 = require("node:fs");
-/** Attachments above this are left unread: a long recording or a huge image is
- *  a different conversation from a spoken line or a screenshot, and the
- *  transfer is not free. */
-const INBOUND_MEDIA_MAX_BYTES = 25 * 1024 * 1024;
 /**
  * How long a file fetched by `fetch-media` stays on disk.
  *
@@ -60,22 +54,14 @@ const fetch_media_1 = require("./fetch-media");
 const channel_runtime_1 = require("openclaw/plugin-sdk/channel-runtime");
 const param_readers_1 = require("openclaw/plugin-sdk/param-readers");
 const tool_send_1 = require("openclaw/plugin-sdk/tool-send");
-const direct_dm_1 = require("openclaw/plugin-sdk/direct-dm");
-const channel_inbound_1 = require("openclaw/plugin-sdk/channel-inbound");
-const channel_reply_pipeline_1 = require("openclaw/plugin-sdk/channel-reply-pipeline");
-const inbound_envelope_1 = require("openclaw/plugin-sdk/inbound-envelope");
-const inbound_reply_dispatch_1 = require("openclaw/plugin-sdk/inbound-reply-dispatch");
 const channel_pairing_1 = require("openclaw/plugin-sdk/channel-pairing");
 const events_1 = require("telegram/events");
-const constants_1 = require("./constants");
 const gramjs_client_1 = require("./gramjs-client");
-const normalize_1 = require("./normalize");
 const history_1 = require("./history");
 const send_scope_1 = require("./send-scope");
 const joins_1 = require("./joins");
 const reactions_1 = require("./reactions");
 const manage_1 = require("./manage");
-const silent_reaction_1 = require("./silent-reaction");
 const system_notice_1 = require("./system-notice");
 const state_dir_1 = require("./state-dir");
 const chat_info_1 = require("./chat-info");
@@ -88,68 +74,8 @@ const group_reply_address_1 = require("./group-reply-address");
 const group_visible_reply_guard_1 = require("./group-visible-reply-guard");
 const helpers_1 = require("./helpers");
 const proxy_config_1 = require("./proxy-config");
-const constants_2 = require("./constants");
+const constants_1 = require("./constants");
 const actionLog = (0, core_1.createSubsystemLogger)("channels/clawgram");
-/** Reads the configured reaction level for an account, tolerating a missing config. */
-function readAccountReactionLevel(cfg, accountId) {
-    const resolvedAccountId = (0, helpers_1.resolveConfiguredAccountId)(cfg, accountId);
-    if (!resolvedAccountId) {
-        return undefined;
-    }
-    return cfg?.channels?.[constants_2.CHANNEL_ID]?.accounts?.[resolvedAccountId]?.reactionLevel;
-}
-/**
- * Model ref for the emoji pick, when the account names one.
- *
- * Picking one emoji out of a fixed list of 68 is the cheapest judgement this
- * channel makes and the only model call it makes on its own; running it on the
- * agent's own head spends the expensive quota on a decision a small model
- * makes just as well.
- */
-function readAccountReactionModel(cfg, accountId) {
-    const resolvedAccountId = (0, helpers_1.resolveConfiguredAccountId)(cfg, accountId);
-    if (!resolvedAccountId) {
-        return undefined;
-    }
-    const raw = cfg?.channels?.[constants_2.CHANNEL_ID]?.accounts?.[resolvedAccountId]?.reactionModel;
-    return typeof raw === "string" && raw.trim() ? raw.trim() : undefined;
-}
-/**
- * Wires `reactToSilentMention` to this account's runtime, config and log.
- *
- * The decision itself lives in `silent-reaction.ts`, testable without a
- * Telegram connection; everything here is lookup. Missing pieces — no
- * connected client, no model access — resolve to no reaction rather than to
- * an error, because by this point the agent has already declined to reply.
- */
-async function reactToSilentMentionForAccount(params) {
-    const gram = params.gram;
-    const llm = params.pluginRuntime?.llm;
-    if (!gram || typeof llm?.complete !== "function") {
-        return;
-    }
-    await (0, silent_reaction_1.reactToSilentMention)({
-        appetite: (0, reactions_1.resolveAgentReactionGuidance)(readAccountReactionLevel(params.cfg, params.accountId)),
-        model: readAccountReactionModel(params.cfg, params.accountId),
-        wasMentioned: params.wasMentioned,
-        chatId: params.chatId,
-        messageId: params.messageId,
-        messageText: params.messageText,
-        deps: {
-            // Bound rather than destructured: the SDK may implement this as a
-            // method that needs its receiver.
-            complete: (args) => llm.complete(args),
-            sendReaction: (args) => gram.sendReaction(args),
-            allowedReactions: gram.getAllowedReactions
-                ? () => gram.getAllowedReactions(params.chatId)
-                : undefined,
-            onDecision: (info) => actionLog.info("clawgram silent-mention reaction", {
-                accountId: params.accountId,
-                ...info,
-            }),
-        },
-    });
-}
 /**
  * Read scope as configured for the account. Left `undefined` when the key is
  * absent so `isChatReadable` can tell "not configured" from "configured empty" —
@@ -244,134 +170,11 @@ function readAccountManageChats(account) {
     const entries = Array.isArray(raw) ? raw : [raw];
     return entries.map((entry) => String(entry).trim()).filter(Boolean);
 }
-/**
- * Every accepted spelling of an action, mapped to its canonical name.
- *
- * One table, not three. The synonyms used to live in
- * `CORE_ACTION_SYNONYMS`, again in `MANAGE_ACTION_ALIASES`, and a third time
- * as `action === "…" || …` chains inside the dispatcher — and the dispatcher
- * read only the chains. A name could therefore be added to a table and to the
- * advertised list and still reach nothing, with the suite none the wiser:
- * it only ever dispatched the native spellings (finding A6-10).
- *
- * `canonicalAction` is now the only place a name is resolved, and
- * `CORE_ACTION_SYNONYMS` below is derived from this table rather than kept
- * beside it.
- */
-const ACTION_ALIASES = {
-    send: "send",
-    read: "read",
-    // `list` is accepted so a caller that guessed the other obvious name is not
-    // silently refused.
-    list: "read",
-    react: "react",
-    joins: "joins",
-    "upload-file": "upload-file",
-    sendAttachment: "upload-file",
-    "fetch-media": "fetch-media",
-    fetchMedia: "fetch-media",
-    "download-media": "fetch-media",
-    downloadMedia: "fetch-media",
-    getMedia: "fetch-media",
-    "download-file": "fetch-media",
-    participants: "participants",
-    members: "participants",
-    "member-info": "participants",
-    topics: "topics",
-    forumTopics: "topics",
-    "thread-list": "topics",
-    dialogs: "dialogs",
-    chats: "dialogs",
-    "channel-list": "dialogs",
-    chatInfo: "chatInfo",
-    getChatInfo: "chatInfo",
-    "channel-info": "chatInfo",
-    chatMetadata: "chatInfo",
-    getChatMetadata: "chatInfo",
-    // Chat management. `kick` was already accepted; the rest were advertised
-    // under names core does not know and were therefore never callable from the
-    // tool at all — 2.19.4 gives them core's nearest name. `transferOwnership`
-    // and `inviteLink` have no counterpart in that vocabulary and stay
-    // gateway-only, as does `joins`.
-    createGroup: "createGroup",
-    createChat: "createGroup",
-    "create-group": "createGroup",
-    "channel-create": "createGroup",
-    addMembers: "addMembers",
-    addMember: "addMembers",
-    "add-members": "addMembers",
-    addParticipant: "addMembers",
-    removeMember: "removeMember",
-    removeMembers: "removeMember",
-    "remove-member": "removeMember",
-    kick: "removeMember",
-    promoteAdmin: "promoteAdmin",
-    promote: "promoteAdmin",
-    "promote-admin": "promoteAdmin",
-    setAdmin: "promoteAdmin",
-    "role-add": "promoteAdmin",
-    demoteAdmin: "demoteAdmin",
-    demote: "demoteAdmin",
-    "demote-admin": "demoteAdmin",
-    "role-remove": "demoteAdmin",
-    transferOwnership: "transferOwnership",
-    transferOwner: "transferOwnership",
-    "transfer-ownership": "transferOwnership",
-    inviteLink: "inviteLink",
-    exportInviteLink: "inviteLink",
-    "invite-link": "inviteLink",
-};
-/** The canonical action for a spelling; an unknown name stays itself. */
-function canonicalAction(action) {
-    return ACTION_ALIASES[action] ?? action;
-}
-/**
- * Core's own name for a clawgram action, and the only thing that makes the
- * action reachable from the agent's `message` tool.
- *
- * Core keys its target policy by `CHANNEL_MESSAGE_ACTION_NAMES`, and an action
- * outside that vocabulary is simultaneously "requires a target" and "does not
- * accept a target" — there is no call that satisfies both. Declaring `chatId`
- * through `messageActionTargetAliases` looks like the fix and is not: core
- * resolves the channel with `getBootstrapChannelPlugin`, which only knows
- * bundled channels, so a plugin channel's declaration is never read. Measured
- * on 2026-08-30 — `thread-list` reached `handleAction` and `topics` did not,
- * from the same caller, on the same chat.
- *
- * Every name on the right maps to core target mode `"none"` except
- * `channel-info`, which is `"channelId"`: the chat arrives in
- * `params.channelId`, a spelling no parser here read until 2.21.0 — so the
- * call fell through to the current chat and answered about the wrong one.
- * `readChatTargetParam` is the single list of accepted spellings now.
- *
- * These spellings are derived from `ACTION_ALIASES` rather than kept beside
- * it; that core actually knows each of them is asserted against the installed
- * core in `core-action-synonyms.test.ts`.
- */
-const CORE_VOCABULARY_SPELLINGS = [
-    "thread-list", "channel-list", "channel-info", "member-info", "download-file",
-    "channel-create", "addParticipant", "kick", "role-add", "role-remove",
-];
-exports.CORE_ACTION_SYNONYMS = Object.fromEntries(CORE_VOCABULARY_SPELLINGS.map((name) => [name, ACTION_ALIASES[name]]));
-/** Canonical actions that go through the chat-management gate. */
-const MANAGE_ACTIONS = new Set([
-    "createGroup", "addMembers", "removeMember",
-    "promoteAdmin", "demoteAdmin", "transferOwnership", "inviteLink",
-]);
-function parseOptionalThreadId(value) {
-    if (typeof value === "number") {
-        return Number.isFinite(value) ? Math.trunc(value) : undefined;
-    }
-    if (typeof value !== "string") {
-        return undefined;
-    }
-    const trimmed = value.trim();
-    if (!trimmed || !/^\d+$/.test(trimmed)) {
-        return undefined;
-    }
-    const parsed = Number.parseInt(trimmed, 10);
-    return Number.isFinite(parsed) ? parsed : undefined;
-}
+const actions_1 = require("./actions");
+Object.defineProperty(exports, "CORE_ACTION_SYNONYMS", { enumerable: true, get: function () { return actions_1.CORE_ACTION_SYNONYMS; } });
+Object.defineProperty(exports, "canonicalAction", { enumerable: true, get: function () { return actions_1.canonicalAction; } });
+const outbound_1 = require("./outbound");
+const inbound_pipeline_1 = require("./inbound-pipeline");
 /**
  * Turns an inbound attachment into text the agent can read.
  *
@@ -385,126 +188,7 @@ function parseOptionalThreadId(value) {
  * "you sent something I could not read" than staying silent, which is
  * indistinguishable from being offline.
  */
-/**
- * Locates the agent directory that image understanding needs.
- *
- * Image models are called with the agent's own credentials, so the pipeline
- * refuses to run without this path — audio does not need it, which is why
- * voice notes worked before images did. The platform exposes no resolver to
- * plugins, so the documented layout is reconstructed here and checked before
- * use: a wrong guess would fail the read anyway, and returning undefined lets
- * the caller degrade instead of throwing.
- */
-function resolveAgentDirForMedia(cfg) {
-    const stateDir = (0, state_dir_1.resolveStateDir)();
-    const configuredId = cfg?.agents?.defaults?.id;
-    const agentId = typeof configuredId === "string" && configuredId.trim() ? configuredId.trim() : "main";
-    const dir = node_path_1.default.join(stateDir, "agents", agentId, "agent");
-    return (0, node_fs_1.existsSync)(dir) ? dir : undefined;
-}
-/**
- * Turns a downloaded attachment into text.
- *
- * Shared by the inbound path and by `fetch-media`: the backend choice lives in
- * `runtime.mediaUnderstanding`, and both callers have to make exactly the same
- * call — an image read on arrival and the same image read on request must not
- * become two different readings because two call sites drifted.
- */
-async function understandAttachmentFile(params) {
-    const media = params.runtime?.mediaUnderstanding;
-    if (!media)
-        return undefined;
-    const result = params.understanding === "transcript"
-        ? await media.transcribeAudioFile({
-            filePath: params.filePath,
-            cfg: params.cfg,
-            mime: params.mimeType,
-        })
-        : await media.describeImageFile({
-            filePath: params.filePath,
-            cfg: params.cfg,
-            mime: params.mimeType,
-            agentDir: resolveAgentDirForMedia(params.cfg),
-        });
-    const text = typeof result?.text === "string" ? result.text.trim() : "";
-    return text || undefined;
-}
-async function readInboundAttachment(params) {
-    const media = params.runtime?.mediaUnderstanding;
-    const message = params.event?.message;
-    if (!media || !message) {
-        return undefined;
-    }
-    let downloaded;
-    try {
-        downloaded = await (0, media_1.downloadInboundMediaToTempFile)({
-            client: params.gram.getClient(),
-            message,
-            maxBytes: INBOUND_MEDIA_MAX_BYTES,
-            tmpDir: node_os_1.default.tmpdir(),
-        });
-    }
-    catch (err) {
-        params.log?.info?.("clawgram attachment download failed", {
-            accountId: params.accountId,
-            chatId: params.chatId,
-            messageId: params.messageId,
-            error: String(err),
-        });
-        return undefined;
-    }
-    if (!downloaded) {
-        return undefined;
-    }
-    try {
-        const read = await understandAttachmentFile({
-            runtime: params.runtime,
-            cfg: params.cfg,
-            filePath: downloaded.path,
-            mimeType: downloaded.mimeType,
-            understanding: downloaded.understanding,
-        });
-        if (!read) {
-            params.log?.info?.("clawgram attachment read empty", {
-                accountId: params.accountId,
-                chatId: params.chatId,
-                messageId: params.messageId,
-                understanding: downloaded.understanding,
-            });
-            return undefined;
-        }
-        params.log?.info?.("clawgram attachment read", {
-            accountId: params.accountId,
-            chatId: params.chatId,
-            messageId: params.messageId,
-            understanding: downloaded.understanding,
-            characters: read.length,
-        });
-        return { text: read, understanding: downloaded.understanding };
-    }
-    catch (err) {
-        params.log?.info?.("clawgram attachment read failed", {
-            accountId: params.accountId,
-            chatId: params.chatId,
-            messageId: params.messageId,
-            understanding: downloaded.understanding,
-            error: String(err),
-        });
-        return undefined;
-    }
-    finally {
-        void (async () => {
-            try {
-                const { rm } = await import("node:fs/promises");
-                const { dirname } = await import("node:path");
-                await rm(dirname(downloaded.path), { recursive: true, force: true });
-            }
-            catch {
-                // Leaving a temp file behind is not worth failing a delivered message.
-            }
-        })();
-    }
-}
+const attachments_1 = require("./attachments");
 const createChannelPlugin = (runtimes, pluginRuntime) => {
     const resolveRuntimeAccountId = (cfg, preferred) => {
         const configured = (0, helpers_1.resolveConfiguredAccountId)(cfg, preferred);
@@ -516,6 +200,20 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
         }
         return configured ?? runtimes.keys().next().value;
     };
+    /**
+     * The connected runtime for an account, or a refusal naming it.
+     *
+     * One helper instead of the eleven copies of this three-liner that used to
+     * sit inside each dispatch branch — the same repetition that made every new
+     * action cost a scaffold (finding A6-11).
+     */
+    const requireRuntimeFor = (id) => {
+        const gram = runtimes.get(id);
+        if (!gram) {
+            throw new Error(`clawgram: runtime not found for account ${id}`);
+        }
+        return gram;
+    };
     return {
         id: "clawgram",
         meta: {
@@ -689,808 +387,10 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
                 });
                 const client = gram.getClient();
                 const eventBuilder = new events_1.NewMessage({});
-                const eventHandler = async (event) => {
-                    try {
-                        const rawMessage = event?.message;
-                        const rawPeerUserId = rawMessage?.peerId?.userId;
-                        const rawPeerChatId = rawMessage?.peerId?.chatId;
-                        const rawPeerChannelId = rawMessage?.peerId?.channelId;
-                        const directLike = rawPeerUserId !== undefined ||
-                            (typeof rawMessage?.chatId === "number" && rawMessage.chatId > 0);
-                        if (directLike) {
-                            log?.info?.("clawgram raw direct-like event", {
-                                accountId,
-                                messageId: String(rawMessage?.id ?? ""),
-                                chatId: String(rawMessage?.chatId ?? ""),
-                                peerUserId: String(rawPeerUserId ?? ""),
-                                peerChatId: String(rawPeerChatId ?? ""),
-                                peerChannelId: String(rawPeerChannelId ?? ""),
-                                senderId: String(rawMessage?.senderId ?? rawMessage?.fromId?.userId ?? ""),
-                                out: rawMessage?.out === true,
-                                textLength: typeof rawMessage?.message === "string" ? rawMessage.message.length : typeof rawMessage?.text === "string" ? rawMessage.text.length : 0,
-                            });
-                        }
-                        const normalized = (0, normalize_1.normalizeTelegramEvent)(event, accountId);
-                        if (!normalized) {
-                            if (directLike) {
-                                log?.info?.("clawgram normalize returned null", {
-                                    accountId,
-                                    messageId: String(rawMessage?.id ?? ""),
-                                    chatId: String(rawMessage?.chatId ?? ""),
-                                    peerUserId: String(rawPeerUserId ?? ""),
-                                });
-                            }
-                            return;
-                        }
-                        const directReplyTarget = normalized.chatType === "direct"
-                            ? undefined
-                            : await (0, helpers_1.resolveReplyTarget)(rawMessage);
-                        const senderProfile = normalized.chatType === "direct"
-                            ? await (0, helpers_1.resolveSenderProfileWithTimeout)(rawMessage, {
-                                senderId: normalized.senderId,
-                                client,
-                            }, 1500)
-                            : await (0, helpers_1.resolveSenderProfile)(rawMessage, {
-                                senderId: normalized.senderId,
-                                client,
-                            });
-                        const replyTarget = normalized.chatType === "direct"
-                            ? normalized.chatId
-                            : await (0, helpers_1.resolveChatTarget)(rawMessage);
-                        if (replyTarget) {
-                            normalized.replyTarget = replyTarget;
-                        }
-                        if (!normalized.senderUsername && senderProfile.username) {
-                            normalized.senderUsername = senderProfile.username;
-                        }
-                        if (!normalized.senderDisplay && senderProfile.display) {
-                            normalized.senderDisplay = senderProfile.display;
-                        }
-                        if (normalized.isOutgoing) {
-                            if (normalized.chatType === "direct") {
-                                log?.info?.("clawgram skipping outgoing direct event", {
-                                    accountId,
-                                    chatId: normalized.chatId,
-                                    messageId: normalized.messageId,
-                                    senderId: normalized.senderId,
-                                });
-                            }
-                            return;
-                        }
-                        if (normalized.chatType === "channel") {
-                            log?.info?.("clawgram skipping channel inbound", {
-                                accountId,
-                                chatId: normalized.chatId,
-                                chatType: normalized.chatType,
-                                messageId: normalized.messageId,
-                            });
-                            return;
-                        }
-                        let text = normalized.text?.trim();
-                        // Whether this sender may reach the agent at all — decided before
-                        // the attachment is fetched.
-                        //
-                        // Reading an attachment downloads up to 25 MB and then spends a
-                        // transcription or vision call on it. That used to happen for
-                        // every photo and voice note from anyone in any group the account
-                        // sits in, and only afterwards was the sender checked against
-                        // `allowFrom`. A stranger could therefore spend the owner's model
-                        // budget at will. None of these checks depend on the message text,
-                        // so they cost nothing to run first.
-                        const inboundSenderId = normalized.senderId ?? normalized.chatId;
-                        const inboundScopes = (0, helpers_1.resolveAccountScopes)(cfg, accountId);
-                        const inboundGroupConfig = normalized.chatType === "group"
-                            ? (0, helpers_1.resolveGroupConfig)(inboundScopes.groups, normalized.chatId)
-                            : undefined;
-                        const senderMayReachAgent = normalized.chatType === "group"
-                            ? Boolean(inboundGroupConfig
-                                && inboundGroupConfig.enabled !== false
-                                && (0, helpers_1.isSenderAllowed)({
-                                    allowFrom: inboundGroupConfig.allowFrom,
-                                    senderId: inboundSenderId,
-                                    senderUsername: normalized.senderUsername,
-                                }))
-                            : (0, helpers_1.isSenderAllowed)({
-                                allowFrom: inboundScopes.allowFrom,
-                                senderId: inboundSenderId,
-                                senderUsername: normalized.senderUsername,
-                            });
-                        // An attachment carries no text of its own, and dropping it as
-                        // "empty" is how the assistant used to go silent on being spoken
-                        // to or shown something. Read it into the body instead: for a
-                        // voice note and a screenshot alike, the attachment *is* the
-                        // message. A caption is kept and the reading appended, because
-                        // "look at this" plus the picture is one thought, not two.
-                        const attachment = senderMayReachAgent ? await readInboundAttachment({
-                            gram,
-                            event,
-                            cfg,
-                            runtime: pluginRuntime,
-                            log,
-                            accountId,
-                            chatId: normalized.chatId,
-                            messageId: normalized.messageId,
-                        }) : undefined;
-                        if (attachment) {
-                            const marker = attachment.understanding === "transcript" ? "голосовое" : "изображение";
-                            const read = `[${marker}] ${attachment.text}`;
-                            text = text ? `${text}\n\n${read}` : read;
-                        }
-                        // What the mention gate is allowed to read.
-                        //
-                        // A transcript is the sender's own speech, so "Тина, посмотри"
-                        // said aloud addresses the agent exactly as typing it would. A
-                        // description is not: it is a vision model reading somebody
-                        // else's content, and a screenshot of a chat where a third party
-                        // wrote "@tina_bot" is not an address to her. Feeding the whole
-                        // body to the gate made every such screenshot wake her up.
-                        const addressableText = (0, helpers_1.resolveAddressableText)({
-                            messageText: normalized.text,
-                            bodyText: text,
-                            understanding: attachment?.understanding,
-                        });
-                        if (!text) {
-                            log?.info?.("clawgram skipping empty inbound text", {
-                                accountId,
-                                chatId: normalized.chatId,
-                                messageId: normalized.messageId,
-                            });
-                            return;
-                        }
-                        const senderId = normalized.senderId ?? normalized.chatId;
-                        const isTelegramServiceDirect = normalized.chatType === "direct" &&
-                            (normalized.chatId === constants_1.TELEGRAM_SERVICE_CHAT_ID || senderId === constants_1.TELEGRAM_SERVICE_CHAT_ID);
-                        const isSavedMessagesDirect = normalized.chatType === "direct" &&
-                            Boolean(selfId) &&
-                            normalized.chatId === selfId &&
-                            senderId === selfId;
-                        if (isTelegramServiceDirect) {
-                            log?.info?.("clawgram skipping Telegram service direct chat", {
-                                accountId,
-                                chatId: normalized.chatId,
-                                messageId: normalized.messageId,
-                                senderId,
-                            });
-                            return;
-                        }
-                        if (isSavedMessagesDirect) {
-                            log?.info?.("clawgram skipping Saved Messages direct chat", {
-                                accountId,
-                                chatId: normalized.chatId,
-                                messageId: normalized.messageId,
-                                senderId,
-                                selfId,
-                            });
-                            return;
-                        }
-                        const senderUsername = normalized.senderUsername;
-                        const senderLabel = normalized.senderDisplay || normalized.senderUsername || senderId;
-                        const conversationTarget = normalized.chatType === "direct"
-                            ? normalized.chatId
-                            : normalized.replyTarget ?? normalized.chatId;
-                        const conversationFallbackTargets = [
-                            normalized.chatType === "direct" ? directReplyTarget : undefined,
-                            normalized.chatType === "direct" ? normalized.replyTarget : undefined,
-                            normalized.chatType === "direct" && normalized.senderUsername ? `@${normalized.senderUsername}` : undefined,
-                            normalized.chatId,
-                        ].filter((target, index, items) => {
-                            if (!target || target === conversationTarget) {
-                                return false;
-                            }
-                            return items.findIndex((candidate) => candidate === target) === index;
-                        });
-                        const sendTextToConversation = async (args) => {
-                            const targets = [conversationTarget, ...conversationFallbackTargets];
-                            // Replies have no per-call parseMode slot — the format is an
-                            // account setting (2.3.1); absent keeps the GramJS default
-                            // (its markdown parser — not plain text, see 2.15.0 notes).
-                            const replyParseMode = gram.replyParseMode;
-                            let lastError;
-                            for (const target of targets) {
-                                try {
-                                    return await gram.sendText({
-                                        target,
-                                        text: args.text,
-                                        replyToMessageId: args.replyToMessageId,
-                                        messageThreadId: args.messageThreadId,
-                                        parseMode: replyParseMode,
-                                    });
-                                }
-                                catch (error) {
-                                    lastError = error;
-                                }
-                            }
-                            throw lastError;
-                        };
-                        // Resolved once, above, before the attachment fetch that depends on
-                        // the answer — and by the same resolver `resolveAccount` uses, so the
-                        // gate applied here is the one the account was started with.
-                        const { allowFrom: directAllowFrom } = inboundScopes;
-                        const dmPolicy = "open";
-                        if (normalized.chatType === "group") {
-                            const groupConfig = inboundGroupConfig;
-                            if (!groupConfig) {
-                                log?.info?.("clawgram skipping group not present in groups config", {
-                                    accountId,
-                                    chatId: normalized.chatId,
-                                    messageId: normalized.messageId,
-                                });
-                                return;
-                            }
-                            if (groupConfig.enabled === false) {
-                                log?.info?.("clawgram skipping disabled group", {
-                                    accountId,
-                                    chatId: normalized.chatId,
-                                    messageId: normalized.messageId,
-                                });
-                                return;
-                            }
-                            if (!(0, helpers_1.isSenderAllowed)({
-                                allowFrom: groupConfig.allowFrom,
-                                senderId,
-                                senderUsername: normalized.senderUsername,
-                            })) {
-                                log?.info?.("clawgram blocking inbound group sender by allowFrom", {
-                                    accountId,
-                                    chatId: normalized.chatId,
-                                    messageId: normalized.messageId,
-                                    senderId,
-                                    username: normalized.senderUsername,
-                                    allowFrom: groupConfig.allowFrom,
-                                });
-                                return;
-                            }
-                            const scopedGroupPeerId = (0, helpers_1.buildScopedGroupPeerId)(accountId, normalized.chatId);
-                            const { route: inboundRoute, buildEnvelope } = (0, inbound_envelope_1.resolveInboundRouteEnvelopeBuilderWithRuntime)({
-                                cfg,
-                                channel: "clawgram",
-                                accountId,
-                                peer: {
-                                    kind: "group",
-                                    id: scopedGroupPeerId,
-                                },
-                                runtime: channelRuntime,
-                                sessionStore: cfg?.session?.store,
-                            });
-                            // channelRuntime comes from the untyped ctx, so the generic route type falls
-                            // back to the minimal RouteLike. The runtime value is a ResolvedAgentRoute.
-                            const route = inboundRoute;
-                            // Under `tag` the name is not an address: in a chat of a thousand
-                            // people it occurs in conversation constantly and is aimed at her
-                            // almost never. Only the `@` counts, and it is the same fact the
-                            // stricter rung of the ladder is named after.
-                            const wasMentioned = groupConfig.groupPolicy === "tag"
-                                ? (0, helpers_1.hasExplicitTelegramMention)({ selfUsername, text: addressableText, message: rawMessage })
-                                : (0, helpers_1.hasTelegramMention)({
-                                    cfg,
-                                    agentId: route.agentId,
-                                    selfUsername,
-                                    text: addressableText,
-                                    message: rawMessage,
-                                });
-                            // One fetch serves two needs: the reply-to-self gate below and
-                            // the parent's text for the agent (ReplyToBody), which a plain
-                            // reply does not carry on its own.
-                            const replyParent = await (0, helpers_1.resolveReplyParent)(rawMessage, { selfId, selfLabel });
-                            const wasReplyToSelf = replyParent.isSelf;
-                            const mentionDecision = (0, channel_inbound_1.resolveInboundMentionDecision)({
-                                facts: {
-                                    canDetectMention: true,
-                                    wasMentioned,
-                                    hasAnyMention: /(^|\s)@[a-zA-Z0-9_]{5,}\b/.test(addressableText),
-                                },
-                                policy: {
-                                    isGroup: true,
-                                    requireMention: groupConfig.groupPolicy !== "open",
-                                    allowTextCommands: false,
-                                    hasControlCommand: false,
-                                    commandAuthorized: true,
-                                },
-                            });
-                            log?.info?.("clawgram group mention gate", {
-                                accountId,
-                                chatId: normalized.chatId,
-                                messageId: normalized.messageId,
-                                selfUsername,
-                                groupPolicy: groupConfig.groupPolicy,
-                                mentionedFlag: rawMessage?.mentioned === true,
-                                hasEntities: Array.isArray(rawMessage?.entities) ? rawMessage.entities.length : 0,
-                                wasMentioned,
-                                wasReplyToSelf,
-                                shouldSkip: mentionDecision.shouldSkip,
-                                textLength: text.length,
-                            });
-                            if (groupConfig.groupPolicy !== "open" && mentionDecision.shouldSkip && !wasReplyToSelf) {
-                                log?.info?.("clawgram skipping group message without mention", {
-                                    accountId,
-                                    chatId: normalized.chatId,
-                                    messageId: normalized.messageId,
-                                    senderId,
-                                });
-                                return;
-                            }
-                            const { storePath, body } = buildEnvelope({
-                                channel: "Telegram",
-                                from: senderLabel,
-                                body: text,
-                                timestamp: normalized.timestamp,
-                            });
-                            const conversationRouteTarget = (0, helpers_1.buildConversationTarget)(normalized.chatId);
-                            const ctxPayload = channelRuntime.reply.finalizeInboundContext({
-                                Body: body,
-                                BodyForAgent: text,
-                                RawBody: text,
-                                CommandBody: text,
-                                From: conversationRouteTarget,
-                                To: conversationRouteTarget,
-                                SessionKey: route.sessionKey,
-                                AccountId: route.accountId ?? accountId,
-                                ChatType: "group",
-                                ConversationLabel: senderLabel,
-                                SenderId: senderId,
-                                SenderUsername: normalized.senderUsername,
-                                SenderName: normalized.senderDisplay,
-                                GroupId: normalized.chatId,
-                                GroupSubject: normalized.chatId,
-                                WasMentioned: mentionDecision.effectiveWasMentioned || wasReplyToSelf,
-                                WasReplyToSelf: wasReplyToSelf,
-                                Provider: "telegram",
-                                Surface: "clawgram",
-                                MessageSid: normalized.messageId,
-                                MessageSidFull: normalized.messageId,
-                                Timestamp: normalized.timestamp,
-                                ReplyToId: normalized.replyToMessageId,
-                                // Core renders these itself as `[Replying to: "…"]` ahead of the
-                                // user body — it keys off Provider being "telegram", which is set
-                                // below. Without them a highlighted reply reaches the agent as
-                                // bare text, and the fragment the person pointed at is lost.
-                                ReplyToQuoteText: normalized.replyQuoteText,
-                                ReplyToIsQuote: normalized.replyIsQuote,
-                                // A plain reply has no highlight; core then falls back to the
-                                // parent's body, which only exists if the channel fetched it.
-                                ReplyToBody: replyParent.body,
-                                ReplyToSender: replyParent.sender,
-                                MessageThreadId: normalized.messageThreadId,
-                                NativeChannelId: normalized.chatId,
-                                // Trusted per-group prompt block from `groups.<id>.systemPrompt`.
-                                // Core normalizes it (`normalizeTrustedTextField`) and appends
-                                // it to the system prompt for this turn. Undefined = no block.
-                                GroupSystemPrompt: groupConfig.systemPrompt,
-                                OriginatingChannel: "clawgram",
-                                OriginatingTo: conversationRouteTarget,
-                            });
-                            const groupReplyAddress = (0, group_reply_address_1.buildGroupReplyAddress)({
-                                senderUsername: normalized.senderUsername,
-                                senderDisplay: normalized.senderDisplay,
-                                senderId,
-                            });
-                            (0, group_reply_address_1.rememberGroupReplyAddress)({
-                                accountId: route.accountId ?? accountId,
-                                chatId: normalized.chatId,
-                                replyToId: normalized.messageId,
-                                address: groupReplyAddress,
-                            });
-                            const messageThreadId = parseOptionalThreadId(normalized.messageThreadId);
-                            const groupTypingTarget = normalized.chatId;
-                            await gram.withTyping(groupTypingTarget, async () => {
-                                log?.info?.("clawgram dispatching group reply", {
-                                    accountId,
-                                    chatId: normalized.chatId,
-                                    messageId: normalized.messageId,
-                                    routeSessionKey: route.sessionKey,
-                                    storePath,
-                                });
-                                await channelRuntime.session.recordInboundSession({
-                                    storePath,
-                                    sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
-                                    ctx: ctxPayload,
-                                    updateLastRoute: {
-                                        sessionKey: route.sessionKey,
-                                        channel: constants_2.CHANNEL_ID,
-                                        to: conversationRouteTarget,
-                                        accountId: route.accountId ?? accountId,
-                                    },
-                                    onRecordError: (err) => {
-                                        log?.info?.("clawgram failed to update group last route", {
-                                            accountId,
-                                            chatId: normalized.chatId,
-                                            messageId: normalized.messageId,
-                                            error: String(err),
-                                        });
-                                    },
-                                });
-                                const dispatchBase = (0, inbound_reply_dispatch_1.buildInboundReplyDispatchBase)({
-                                    cfg,
-                                    channel: "clawgram",
-                                    accountId: route.accountId ?? accountId,
-                                    route,
-                                    storePath,
-                                    ctxPayload,
-                                    core: { channel: channelRuntime },
-                                });
-                                const { onModelSelected, ...replyPipeline } = (0, channel_reply_pipeline_1.createChannelReplyPipeline)({
-                                    cfg,
-                                    agentId: route.agentId,
-                                    channel: "clawgram",
-                                    accountId: route.accountId ?? accountId,
-                                });
-                                // Boundary for the transcript fallback below: only replies
-                                // written after this instant may be salvaged. Same clock as
-                                // the transcript writer — both live in this process.
-                                const dispatchStartedAt = Date.now();
-                                const dispatchResult = await dispatchBase.dispatchReplyWithBufferedBlockDispatcher({
-                                    ctx: ctxPayload,
-                                    cfg,
-                                    dispatcherOptions: {
-                                        ...replyPipeline,
-                                        deliver: async (payload) => {
-                                            const outboundText = typeof payload.text === "string" ? payload.text.trim() : "";
-                                            log?.info?.("clawgram deliver group payload", {
-                                                accountId,
-                                                chatId: normalized.chatId,
-                                                messageId: normalized.messageId,
-                                                payloadTextLength: outboundText.length,
-                                                payloadReplyToId: payload.replyToId ?? null,
-                                            });
-                                            if (!outboundText) {
-                                                return;
-                                            }
-                                            // The agent may decline to answer by returning the shared
-                                            // silent token. Drop it before addressing: otherwise the
-                                            // reply-address prefix turns it into a visible message.
-                                            const visibleText = (0, helpers_1.stripSilentReplyToken)(outboundText);
-                                            if (!visibleText) {
-                                                log?.info?.("clawgram suppressing silent group reply", {
-                                                    accountId,
-                                                    chatId: normalized.chatId,
-                                                    messageId: normalized.messageId,
-                                                });
-                                                return;
-                                            }
-                                            // Ядро подклеивает свою телеметрию к полезной нагрузке
-                                            // хода, и сюда она приходит тем же путём, что ответ.
-                                            // Проверка стояла только в `outbound.sendText`, то есть
-                                            // класс инцидента 30.08–01.09 был закрыт для рассылок и
-                                            // открыт для обычного ответа на упоминание (A5-10).
-                                            const groupNotice = (0, system_notice_1.shouldSuppressGroupSystemNotice)({
-                                                targetKind: "group",
-                                                text: visibleText,
-                                            });
-                                            if (groupNotice) {
-                                                log?.warn?.("clawgram suppressing system notice in group reply", {
-                                                    accountId,
-                                                    chatId: normalized.chatId,
-                                                    messageId: normalized.messageId,
-                                                    noticeKind: groupNotice,
-                                                    textLength: visibleText.length,
-                                                });
-                                                return;
-                                            }
-                                            const replyToMessageId = payload.replyToId ? Number(payload.replyToId) : Number(normalized.messageId);
-                                            const rememberedAddress = (0, group_reply_address_1.consumeGroupReplyAddress)({
-                                                accountId: route.accountId ?? accountId,
-                                                chatId: normalized.chatId,
-                                                replyToId: payload.replyToId ?? normalized.messageId,
-                                            });
-                                            await sendTextToConversation({
-                                                text: (0, helpers_1.prefixReplyTextToAddress)(visibleText, rememberedAddress ?? groupReplyAddress),
-                                                replyToMessageId,
-                                                messageThreadId,
-                                            });
-                                        },
-                                        onError: (err, info) => {
-                                            log?.error?.("clawgram failed to dispatch group reply", {
-                                                accountId,
-                                                chatId: normalized.chatId,
-                                                messageId: normalized.messageId,
-                                                kind: info.kind,
-                                                error: String(err),
-                                            });
-                                        },
-                                    },
-                                    replyOptions: {
-                                        onModelSelected,
-                                        // `groups.<id>.skills` → core's per-turn skill allowlist.
-                                        // Undefined = inherit the agent's skills; [] = none here.
-                                        skillFilter: groupConfig.skillFilter,
-                                    },
-                                });
-                                log?.info?.("clawgram group dispatch completed", {
-                                    accountId,
-                                    chatId: normalized.chatId,
-                                    messageId: normalized.messageId,
-                                    queuedFinal: dispatchResult?.queuedFinal ?? null,
-                                    counts: dispatchResult?.counts ?? null,
-                                });
-                                const dispatchCounts = dispatchResult?.counts ?? { tool: 0, block: 0, final: 0 };
-                                const nothingDelivered = dispatchResult?.queuedFinal !== true &&
-                                    (dispatchCounts.tool ?? 0) === 0 &&
-                                    (dispatchCounts.block ?? 0) === 0 &&
-                                    (dispatchCounts.final ?? 0) === 0;
-                                if (nothingDelivered) {
-                                    const fallbackText = (0, helpers_1.readLatestAssistantFallbackFromTranscript)(route.sessionKey, storePath, dispatchStartedAt);
-                                    // A suppressed silent reply legitimately delivers nothing, so
-                                    // this fallback fires right after it. Without the same check
-                                    // the token would be read back from the transcript and sent.
-                                    //
-                                    // TTS markup needs the same treatment for the same reason:
-                                    // core strips it on the normal reply path, but this text comes
-                                    // straight out of the transcript. On 2026-08-08 a group got
-                                    // `[[tts:text]]Привет, Вася!…[[/tts:text]]` verbatim. The
-                                    // spoken words are kept — a synthesis that did not happen
-                                    // should degrade to readable text, not to markup.
-                                    const rawFallback = fallbackText
-                                        ? (0, helpers_1.stripTtsDirectives)((0, helpers_1.stripSilentReplyToken)(fallbackText))
-                                        : "";
-                                    // Тот же фильтр и здесь: последняя реплика в стенограмме
-                                    // вполне может оказаться именно уведомлением об ошибке.
-                                    const fallbackNotice = rawFallback
-                                        ? (0, system_notice_1.shouldSuppressGroupSystemNotice)({ targetKind: "group", text: rawFallback })
-                                        : undefined;
-                                    if (fallbackNotice) {
-                                        log?.warn?.("clawgram suppressing system notice in transcript fallback", {
-                                            accountId,
-                                            chatId: normalized.chatId,
-                                            messageId: normalized.messageId,
-                                            noticeKind: fallbackNotice,
-                                            textLength: rawFallback.length,
-                                        });
-                                    }
-                                    const visibleFallbackText = fallbackNotice ? "" : rawFallback;
-                                    if (!visibleFallbackText) {
-                                        if (fallbackText) {
-                                            log?.info?.("clawgram skipping silent transcript fallback", {
-                                                accountId,
-                                                chatId: normalized.chatId,
-                                                messageId: normalized.messageId,
-                                                routeSessionKey: route.sessionKey,
-                                            });
-                                        }
-                                        else {
-                                            log?.warn?.("clawgram transcript fallback unavailable", {
-                                                accountId,
-                                                chatId: normalized.chatId,
-                                                messageId: normalized.messageId,
-                                                routeSessionKey: route.sessionKey,
-                                            });
-                                        }
-                                        // Named, and nothing came back: leave a reaction so the
-                                        // decision is visible instead of reading as her ignoring
-                                        // people. The condition is her silence, not the shape of
-                                        // the transcript — a turn that wrote no entry at all is
-                                        // just as silent as one that wrote the NO_REPLY token.
-                                        //
-                                        // Never allowed to disturb the turn: the reply is already
-                                        // settled by this point, so a failure here stays silent.
-                                        await reactToSilentMentionForAccount({
-                                            cfg,
-                                            accountId,
-                                            gram: runtimes.get(accountId),
-                                            pluginRuntime,
-                                            chatId: normalized.chatId,
-                                            messageId: normalized.messageId,
-                                            messageText: normalized.text,
-                                            // Same sense of "addressed" the agent was given for this
-                                            // turn on line 817: a reply to her own message counts as
-                                            // being spoken to, mention or not.
-                                            wasMentioned: mentionDecision.effectiveWasMentioned || wasReplyToSelf,
-                                        }).catch((err) => {
-                                            log?.info?.("clawgram silent-mention reaction failed", {
-                                                accountId,
-                                                chatId: normalized.chatId,
-                                                messageId: normalized.messageId,
-                                                error: String(err),
-                                            });
-                                        });
-                                    }
-                                    else {
-                                        log?.warn?.("clawgram using transcript fallback reply", {
-                                            accountId,
-                                            chatId: normalized.chatId,
-                                            messageId: normalized.messageId,
-                                            routeSessionKey: route.sessionKey,
-                                            fallbackTextLength: visibleFallbackText.length,
-                                        });
-                                        await sendTextToConversation({
-                                            text: (0, helpers_1.prefixReplyTextToAddress)(visibleFallbackText, groupReplyAddress),
-                                            replyToMessageId: Number(normalized.messageId),
-                                            messageThreadId,
-                                        });
-                                    }
-                                }
-                            }, {
-                                readMessageId: Number(normalized.messageId),
-                                messageThreadId,
-                                // The indicator is a promise of an answer, and it is owed only
-                                // to someone who addressed her. Under `open` the turn runs on
-                                // every message in the chat, so without this the whole room
-                                // watches her "type" through conversations she is only reading.
-                                typing: mentionDecision.effectiveWasMentioned || wasReplyToSelf,
-                            });
-                            log?.info?.("clawgram group inbound handled", {
-                                accountId,
-                                chatId: normalized.chatId,
-                                messageId: normalized.messageId,
-                                senderId,
-                                senderLabel,
-                                wasMentioned: mentionDecision.effectiveWasMentioned,
-                                wasReplyToSelf,
-                            });
-                            return;
-                        }
-                        if (!(0, helpers_1.isSenderAllowed)({
-                            allowFrom: directAllowFrom,
-                            senderId,
-                            senderUsername: normalized.senderUsername,
-                        })) {
-                            log?.info?.("clawgram direct allowFrom mismatch", {
-                                accountId,
-                                senderId,
-                                senderUsername: normalized.senderUsername,
-                                allowFrom: directAllowFrom,
-                            });
-                            return;
-                        }
-                        const access = await (0, direct_dm_1.resolveInboundDirectDmAccessWithRuntime)({
-                            cfg,
-                            channel: "clawgram",
-                            accountId,
-                            dmPolicy,
-                            allowFrom: directAllowFrom,
-                            senderId,
-                            rawBody: text,
-                            runtime: channelRuntime.commands,
-                            isSenderAllowed: (_candidateSenderId, allowEntries) => (0, helpers_1.isSenderAllowed)({
-                                allowFrom: allowEntries,
-                                senderId,
-                                senderUsername,
-                            }),
-                            readStoreAllowFrom: pairing.readStoreForDmPolicy,
-                        });
-                        if (access.access.decision === "block") {
-                            log?.info?.("clawgram blocking inbound direct message", {
-                                accountId,
-                                chatId: normalized.chatId,
-                                messageId: normalized.messageId,
-                                senderId,
-                                reason: access.access.reason,
-                                reasonCode: access.access.reasonCode,
-                            });
-                            return;
-                        }
-                        if (access.access.decision === "pairing") {
-                            await pairing.issueChallenge({
-                                senderId,
-                                senderIdLine: `Your Telegram user id: ${senderId}`,
-                                meta: {
-                                    username: normalized.senderUsername,
-                                    name: normalized.senderDisplay,
-                                },
-                                sendPairingReply: async (pairingText) => {
-                                    await sendTextToConversation({
-                                        text: pairingText,
-                                    });
-                                },
-                                onReplyError: (err) => {
-                                    log?.info?.("clawgram pairing reply failed", {
-                                        accountId,
-                                        chatId: normalized.chatId,
-                                        senderId,
-                                        error: String(err),
-                                    });
-                                },
-                            });
-                            log?.info?.("clawgram pairing required for inbound direct message", {
-                                accountId,
-                                chatId: normalized.chatId,
-                                messageId: normalized.messageId,
-                                senderId,
-                            });
-                            return;
-                        }
-                        // Same fetch as the group path. In a DM the parent is as often
-                        // the agent's own message as the person's — the owner answers a
-                        // notice she sent — and neither text is available any other way.
-                        const replyParent = await (0, helpers_1.resolveReplyParent)(rawMessage, { selfId, selfLabel });
-                        await gram.withTyping(conversationTarget, async () => {
-                            await (0, direct_dm_1.dispatchInboundDirectDmWithRuntime)({
-                                cfg,
-                                runtime: { channel: channelRuntime },
-                                channel: "clawgram",
-                                channelLabel: "Telegram",
-                                accountId,
-                                peer: {
-                                    kind: "direct",
-                                    id: senderId,
-                                },
-                                senderId,
-                                senderAddress: `telegram:${senderId}`,
-                                recipientAddress: selfId ? `telegram:${selfId}` : `telegram:${accountId}`,
-                                conversationLabel: senderLabel,
-                                rawBody: text,
-                                messageId: normalized.messageId,
-                                timestamp: normalized.timestamp,
-                                commandAuthorized: access.commandAuthorized,
-                                provider: "telegram",
-                                surface: "clawgram",
-                                originatingChannel: "clawgram",
-                                originatingTo: senderId,
-                                extraContext: {
-                                    SenderUsername: normalized.senderUsername,
-                                    SenderName: normalized.senderDisplay,
-                                    ReplyToId: normalized.replyToMessageId,
-                                    // Same reason as the group path: highlighted replies happen in
-                                    // direct messages too, and the fragment is not part of the text.
-                                    ReplyToQuoteText: normalized.replyQuoteText,
-                                    ReplyToIsQuote: normalized.replyIsQuote,
-                                    ReplyToBody: replyParent.body,
-                                    ReplyToSender: replyParent.sender,
-                                    NativeChannelId: normalized.chatId,
-                                },
-                                deliver: async (payload) => {
-                                    const outboundText = typeof payload.text === "string" ? payload.text.trim() : "";
-                                    if (!outboundText) {
-                                        return;
-                                    }
-                                    const visibleText = (0, helpers_1.stripSilentReplyToken)(outboundText);
-                                    if (!visibleText) {
-                                        log?.info?.("clawgram suppressing silent direct reply", {
-                                            accountId,
-                                            chatId: normalized.chatId,
-                                            messageId: normalized.messageId,
-                                        });
-                                        return;
-                                    }
-                                    await sendTextToConversation({
-                                        text: visibleText,
-                                        replyToMessageId: payload.replyToId ? Number(payload.replyToId) : undefined,
-                                    });
-                                },
-                                onRecordError: (err) => {
-                                    log?.info?.("clawgram failed to record inbound session", {
-                                        accountId,
-                                        chatId: normalized.chatId,
-                                        messageId: normalized.messageId,
-                                        error: String(err),
-                                    });
-                                },
-                                onDispatchError: (err, info) => {
-                                    log?.info?.("clawgram failed to dispatch reply", {
-                                        accountId,
-                                        chatId: normalized.chatId,
-                                        messageId: normalized.messageId,
-                                        kind: info.kind,
-                                        error: String(err),
-                                    });
-                                },
-                            });
-                        }, {
-                            readMessageId: Number(normalized.messageId),
-                        });
-                        log?.info?.("clawgram inbound handled", {
-                            accountId,
-                            chatId: normalized.chatId,
-                            messageId: normalized.messageId,
-                            senderId,
-                            senderLabel,
-                        });
-                    }
-                    catch (error) {
-                        const rawMessage = event?.message;
-                        log?.error?.("clawgram inbound handling failed", {
-                            accountId,
-                            chatId: String(rawMessage?.chatId ?? rawMessage?.peerId?.userId ?? rawMessage?.peerId?.chatId ?? rawMessage?.peerId?.channelId ?? ""),
-                            messageId: String(rawMessage?.id ?? ""),
-                            error: String(error),
-                        });
-                        log?.info?.("clawgram inbound preflight failed", {
-                            accountId,
-                            chatId: String(rawMessage?.chatId ?? rawMessage?.peerId?.userId ?? rawMessage?.peerId?.chatId ?? rawMessage?.peerId?.channelId ?? ""),
-                            messageId: String(rawMessage?.id ?? ""),
-                            error: String(error),
-                        });
-                    }
-                };
+                const eventHandler = async (event) => (0, inbound_pipeline_1.handleInboundEvent)(event, {
+                    accountId, cfg, channelRuntime, client, gram, log, pairing,
+                    pluginRuntime, runtimes, selfId, selfLabel, selfUsername,
+                });
                 client.addEventHandler(eventHandler, eventBuilder);
                 // Being added to a chat arrives as a service message, which `NewMessage`
                 // drops — so joins are observed on the raw update stream instead. Only
@@ -1539,7 +439,7 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
             },
         },
         messaging: {
-            targetPrefixes: [constants_2.CHANNEL_ID, "tguserbot", "telegram", "tg"],
+            targetPrefixes: [constants_1.CHANNEL_ID, "tguserbot", "telegram", "tg"],
             normalizeTarget(raw) {
                 const normalized = (0, helpers_1.normalizeOutboundTarget)(raw);
                 return normalized || undefined;
@@ -1611,7 +511,7 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
                 return (0, core_1.buildChannelOutboundSessionRoute)({
                     cfg: params.cfg,
                     agentId: params.agentId,
-                    channel: constants_2.CHANNEL_ID,
+                    channel: constants_1.CHANNEL_ID,
                     accountId,
                     peer: {
                         kind: (0, helpers_1.routeKindFromChatType)(chatType),
@@ -1722,7 +622,7 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
                 // resolved once, here, and `ACTION_ALIASES` is the only place that
                 // decides what a name means. An unknown name stays itself and falls
                 // through to the unsupported-action error, as before.
-                const canonical = canonicalAction(action);
+                const canonical = (0, actions_1.canonicalAction)(action);
                 // `read` is what OpenClaw core dispatches (`openclaw message read`,
                 // MCP `messages_read`); `list` resolves to it too.
                 if (canonical === "read") {
@@ -1837,7 +737,7 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
                     const downloaded = await (0, media_1.downloadMessageMediaToFile)({
                         client: fetchGram.getClient(),
                         message: found.message,
-                        maxBytes: INBOUND_MEDIA_MAX_BYTES,
+                        maxBytes: attachments_1.INBOUND_MEDIA_MAX_BYTES,
                         dir: fetchDir,
                         fileNameFor: ({ media, extension }) => (0, fetch_media_1.fetchedMediaFileName)({
                             chatId: fetchChatId,
@@ -1853,7 +753,7 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
                         // large to be worth the transfer. Saying "could not fetch" to all
                         // three is how "she ignored the picture" starts.
                         const described = (0, media_1.describeMedia)(found.message?.media);
-                        const tooLarge = typeof described?.size === "number" && described.size > INBOUND_MEDIA_MAX_BYTES;
+                        const tooLarge = typeof described?.size === "number" && described.size > attachments_1.INBOUND_MEDIA_MAX_BYTES;
                         const error = !described
                             ? "no-media"
                             : tooLarge
@@ -1879,7 +779,7 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
                     let readError;
                     if (fetchParams.mode !== "file") {
                         try {
-                            read = await understandAttachmentFile({
+                            read = await (0, attachments_1.understandAttachmentFile)({
                                 runtime: pluginRuntime,
                                 cfg,
                                 filePath: downloaded.path,
@@ -1933,43 +833,80 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
                         readError,
                     });
                 }
-                // Membership is a read, so the same `readChats` scope that gates history
-                // gates it too: this cannot become a way to enumerate chats the account
-                // was never allowed to read.
-                if (canonical === "participants") {
-                    const participantsParams = (0, history_1.parseListParticipantsParams)(params);
-                    const participantsAccountId = resolveRuntimeAccountId(cfg, accountId);
-                    if (!participantsAccountId) {
+                /**
+                 * The scaffold every chat-shaped read shares.
+                 *
+                 * `participants`, `topics`, `dialogs`, `joins` and `chatInfo` each
+                 * spelled out the same sequence: parse, resolve the account, check a
+                 * scope, fetch the runtime, call it, log counts, answer. Roughly
+                 * forty lines apiece, differing in four places — which is how a new
+                 * action came to cost sixty lines of scaffold and how the two gates
+                 * drifted apart (finding A6-11).
+                 *
+                 * The gate follows from the shape rather than being restated: an
+                 * action that names a chat is gated by `readChats`, `dialogs` has its
+                 * own discovery gate precisely because its point is to find chats
+                 * that are not in scope yet, and `joins` has none — the journal only
+                 * ever holds chats this account was put into.
+                 *
+                 * The runtime is a getter, not a value: `joins` reads a file and must
+                 * not fail merely because no runtime is connected.
+                 */
+                const runRead = async (spec) => {
+                    const parsed = spec.parse();
+                    const readAccountId = resolveRuntimeAccountId(cfg, accountId);
+                    if (!readAccountId) {
                         throw new Error("clawgram: no configured account found");
                     }
-                    if (!(0, history_1.isChatReadable)(participantsParams.target, resolveAccountReadChats(cfg, participantsAccountId))) {
-                        actionLog.warn("clawgram participants refused: chat outside read scope", {
-                            accountId: participantsAccountId,
-                            target: participantsParams.target,
-                        });
-                        throw new Error(`clawgram: not-allowed-chat ${participantsParams.target}`);
+                    const target = spec.target?.(parsed);
+                    if (target !== undefined) {
+                        if (!(0, history_1.isChatReadable)(target, resolveAccountReadChats(cfg, readAccountId))) {
+                            actionLog.warn(`clawgram ${spec.name} refused: chat outside read scope`, {
+                                accountId: readAccountId,
+                                target,
+                            });
+                            throw new Error(`clawgram: not-allowed-chat ${target}`);
+                        }
                     }
-                    const participantsGram = runtimes.get(participantsAccountId);
-                    if (!participantsGram) {
-                        throw new Error(`clawgram: runtime not found for account ${participantsAccountId}`);
+                    else if (spec.discovery) {
+                        if (!(0, dialogs_1.isChatDiscoveryEnabled)(resolveAccountDiscoverChats(cfg, readAccountId))) {
+                            actionLog.warn(`clawgram ${spec.name} refused: chat-discovery is not enabled`, {
+                                accountId: readAccountId,
+                            });
+                            throw new Error("clawgram: chat-discovery is not enabled");
+                        }
                     }
-                    const membership = await participantsGram.listParticipants(participantsParams);
-                    // Counts only. Member ids are personal data and have no business in a
-                    // log that is read while debugging something else.
-                    actionLog.info("clawgram handleAction participants completed", {
-                        accountId: participantsAccountId,
-                        target: participantsParams.target,
-                        limit: participantsParams.limit,
-                        returned: membership.participants.length,
-                        truncated: membership.truncated,
+                    const gram = () => requireRuntimeFor(readAccountId);
+                    const result = await spec.run({ parsed, accountId: readAccountId, gram });
+                    actionLog.info(`clawgram handleAction ${spec.name} completed`, {
+                        accountId: readAccountId,
+                        ...spec.after(parsed, result),
                     });
-                    return (0, core_1.jsonResult)({
-                        ok: true,
-                        accountId: participantsAccountId,
-                        chatId: membership.chatId ?? participantsParams.target,
-                        count: membership.participants.length,
-                        truncated: membership.truncated,
-                        participants: membership.participants,
+                    return (0, core_1.jsonResult)({ ok: true, accountId: readAccountId, ...spec.result(parsed, result) });
+                };
+                // Membership is a read, so the same `readChats` scope that gates history
+                // gates it too: this cannot become a way to enumerate chats the account
+                // was never allowed to read.
+                if (canonical === "participants") {
+                    return await runRead({
+                        name: "participants",
+                        parse: () => (0, history_1.parseListParticipantsParams)(params),
+                        target: (p) => p.target,
+                        run: ({ parsed, gram }) => gram().listParticipants(parsed),
+                        // Counts only. Member ids are personal data and have no business in
+                        // a log that is read while debugging something else.
+                        after: (p, m) => ({
+                            target: p.target,
+                            limit: p.limit,
+                            returned: m.participants.length,
+                            truncated: m.truncated,
+                        }),
+                        result: (p, m) => ({
+                            chatId: m.chatId ?? p.target,
+                            count: m.participants.length,
+                            truncated: m.truncated,
+                            participants: m.participants,
+                        }),
                     });
                 }
                 // Topic names. A forum chat is addressed by topic id, and until now an
@@ -1977,133 +914,77 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
                 // written in yet was unreachable, and one named in words was unfindable.
                 // Titles say what a chat is working on, so the read scope gates them.
                 if (canonical === "topics") {
-                    const topicsParams = (0, topics_1.parseTopicsParams)(params);
-                    const topicsAccountId = resolveRuntimeAccountId(cfg, accountId);
-                    if (!topicsAccountId) {
-                        throw new Error("clawgram: no configured account found");
-                    }
-                    if (!(0, history_1.isChatReadable)(topicsParams.target, resolveAccountReadChats(cfg, topicsAccountId))) {
-                        actionLog.warn("clawgram topics refused: chat outside read scope", {
-                            accountId: topicsAccountId,
-                            target: topicsParams.target,
-                        });
-                        throw new Error(`clawgram: not-allowed-chat ${topicsParams.target}`);
-                    }
-                    const topicsGram = runtimes.get(topicsAccountId);
-                    if (!topicsGram) {
-                        throw new Error(`clawgram: runtime not found for account ${topicsAccountId}`);
-                    }
-                    const forum = await topicsGram.listTopics(topicsParams);
-                    actionLog.info("clawgram handleAction topics completed", {
-                        accountId: topicsAccountId,
-                        target: topicsParams.target,
-                        limit: topicsParams.limit,
-                        returned: forum.topics.length,
-                        truncated: forum.truncated,
-                    });
-                    return (0, core_1.jsonResult)({
-                        ok: true,
-                        accountId: topicsAccountId,
-                        chatId: forum.chatId ?? topicsParams.target,
-                        count: forum.topics.length,
-                        truncated: forum.truncated,
-                        topics: forum.topics,
+                    return await runRead({
+                        name: "topics",
+                        parse: () => (0, topics_1.parseTopicsParams)(params),
+                        target: (p) => p.target,
+                        run: ({ parsed, gram }) => gram().listTopics(parsed),
+                        after: (p, f) => ({
+                            target: p.target,
+                            limit: p.limit,
+                            returned: f.topics.length,
+                            truncated: f.truncated,
+                        }),
+                        result: (p, f) => ({
+                            chatId: f.chatId ?? p.target,
+                            count: f.topics.length,
+                            truncated: f.truncated,
+                            topics: f.topics,
+                        }),
                     });
                 }
                 // Which chats this account is in. Not gated by `readChats` — the whole
                 // point is to find chats that are not in it yet — so it has a gate of
                 // its own, is metadata only, and never reports direct chats.
                 if (canonical === "dialogs") {
-                    const dialogsParams = (0, dialogs_1.parseDialogsParams)(params);
-                    const dialogsAccountId = resolveRuntimeAccountId(cfg, accountId);
-                    if (!dialogsAccountId) {
-                        throw new Error("clawgram: no configured account found");
-                    }
-                    if (!(0, dialogs_1.isChatDiscoveryEnabled)(resolveAccountDiscoverChats(cfg, dialogsAccountId))) {
-                        actionLog.warn("clawgram dialogs refused: chat-discovery is not enabled", {
-                            accountId: dialogsAccountId,
-                        });
-                        throw new Error("clawgram: chat-discovery is not enabled");
-                    }
-                    const dialogsGram = runtimes.get(dialogsAccountId);
-                    if (!dialogsGram) {
-                        throw new Error(`clawgram: runtime not found for account ${dialogsAccountId}`);
-                    }
-                    const found = await dialogsGram.listDialogs(dialogsParams);
-                    // Counts only: which chats a person's account sits in is exactly the
-                    // kind of thing that should not be sitting in a log.
-                    actionLog.info("clawgram handleAction dialogs completed", {
-                        accountId: dialogsAccountId,
-                        limit: dialogsParams.limit,
-                        returned: found.dialogs.length,
-                        truncated: found.truncated,
-                    });
-                    return (0, core_1.jsonResult)({
-                        ok: true,
-                        accountId: dialogsAccountId,
-                        count: found.dialogs.length,
-                        truncated: found.truncated,
-                        dialogs: found.dialogs,
+                    return await runRead({
+                        name: "dialogs",
+                        parse: () => (0, dialogs_1.parseDialogsParams)(params),
+                        discovery: true,
+                        run: ({ parsed, gram }) => gram().listDialogs(parsed),
+                        // Counts only: which chats a person's account sits in is exactly
+                        // the kind of thing that should not be sitting in a log.
+                        after: (p, f) => ({ limit: p.limit, returned: f.dialogs.length, truncated: f.truncated }),
+                        result: (_p, f) => ({ count: f.dialogs.length, truncated: f.truncated, dialogs: f.dialogs }),
                     });
                 }
                 // Where this account was recently added, and by whom. Reading the journal
                 // has no scope check of its own: it only ever contains chats this account
                 // was put into, which is exactly what the caller is allowed to learn.
                 if (canonical === "joins") {
-                    const joinsParams = (0, joins_1.parseJoinsParams)(params);
-                    const joinsAccountId = resolveRuntimeAccountId(cfg, accountId);
-                    if (!joinsAccountId) {
-                        throw new Error("clawgram: no configured account found");
-                    }
-                    const journalPath = (0, joins_1.resolveJoinsJournalPath)(cfg?.channels?.["clawgram"]?.accounts?.[joinsAccountId], joinsAccountId);
-                    const selected = (0, joins_1.selectJoinRecords)((0, joins_1.readJoinRecords)(journalPath), joinsParams);
-                    actionLog.info("clawgram handleAction joins completed", {
-                        accountId: joinsAccountId,
-                        since: joinsParams.since ?? null,
-                        limit: joinsParams.limit,
-                        returned: selected.length,
-                    });
-                    return (0, core_1.jsonResult)({
-                        ok: true,
-                        accountId: joinsAccountId,
-                        count: selected.length,
-                        joins: selected,
+                    return await runRead({
+                        name: "joins",
+                        parse: () => (0, joins_1.parseJoinsParams)(params),
+                        // No runtime: this reads a file, and must answer with none connected.
+                        run: async ({ parsed, accountId: joinsAccountId }) => (0, joins_1.selectJoinRecords)((0, joins_1.readJoinRecords)((0, joins_1.resolveJoinsJournalPath)(cfg?.channels?.["clawgram"]?.accounts?.[joinsAccountId], joinsAccountId)), parsed),
+                        after: (p, selected) => ({
+                            since: p.since ?? null,
+                            limit: p.limit,
+                            returned: selected.length,
+                        }),
+                        result: (_p, selected) => ({ count: selected.length, joins: selected }),
                     });
                 }
                 // Describing a chat is a read, so the same `readChats` scope that gates
                 // history gates it too — this must not become a way to learn the title
                 // and size of a chat the account was never allowed to read.
                 if (canonical === "chatInfo") {
-                    const chatInfoParams = (0, chat_info_1.parseChatInfoParams)(params, toolContext);
-                    const chatInfoAccountId = resolveRuntimeAccountId(cfg, accountId);
-                    if (!chatInfoAccountId) {
-                        throw new Error("clawgram: no configured account found");
-                    }
-                    if (!(0, history_1.isChatReadable)(chatInfoParams.target, resolveAccountReadChats(cfg, chatInfoAccountId))) {
-                        actionLog.warn("clawgram chatInfo refused: chat outside read scope", {
-                            accountId: chatInfoAccountId,
-                            target: chatInfoParams.target,
-                        });
-                        throw new Error(`clawgram: not-allowed-chat ${chatInfoParams.target}`);
-                    }
-                    const chatInfoGram = runtimes.get(chatInfoAccountId);
-                    if (!chatInfoGram) {
-                        throw new Error(`clawgram: runtime not found for account ${chatInfoAccountId}`);
-                    }
-                    const { entity, full } = await chatInfoGram.getChatInfo(chatInfoParams.target);
-                    const info = (0, chat_info_1.describeChat)(entity, full);
-                    // Type and size only. The title of a private chat is as personal as
-                    // its contents and has no business in a debugging log.
-                    actionLog.info("clawgram handleAction chatInfo completed", {
-                        accountId: chatInfoAccountId,
-                        type: info.type,
-                        memberCount: info.memberCount ?? null,
-                        isForum: info.isForum ?? null,
-                    });
-                    return (0, core_1.jsonResult)({
-                        ok: true,
-                        accountId: chatInfoAccountId,
-                        chat: { ...info, chatId: info.chatId ?? chatInfoParams.target },
+                    return await runRead({
+                        name: "chatInfo",
+                        parse: () => (0, chat_info_1.parseChatInfoParams)(params, toolContext),
+                        target: (p) => p.target,
+                        run: async ({ parsed, gram }) => {
+                            const { entity, full } = await gram().getChatInfo(parsed.target);
+                            return (0, chat_info_1.describeChat)(entity, full);
+                        },
+                        // Type and size only. The title of a private chat is as personal as
+                        // its contents and has no business in a debugging log.
+                        after: (_p, info) => ({
+                            type: info.type,
+                            memberCount: info.memberCount ?? null,
+                            isForum: info.isForum ?? null,
+                        }),
+                        result: (p, info) => ({ chat: { ...info, chatId: info.chatId ?? p.target } }),
                     });
                 }
                 // A reaction is an outbound act on someone else's message, so it is
@@ -2164,15 +1045,43 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
                 // returns after the gate so a dry run exercises the same refusals a
                 // real call would hit. People's ids stay out of the logs throughout;
                 // the JSON result carries them to the caller, the journal does not.
-                const manageAction = MANAGE_ACTIONS.has(canonical) ? canonical : undefined;
+                const manageAction = actions_1.MANAGE_ACTIONS.has(canonical) ? canonical : undefined;
                 if (manageAction) {
                     const manageAccountId = resolveRuntimeAccountId(cfg, accountId);
                     if (!manageAccountId) {
                         throw new Error("clawgram: no configured account found");
                     }
                     const manageScope = resolveAccountManageChats(cfg, manageAccountId);
-                    const requireManagedChat = (target) => {
-                        if (!(0, manage_1.isChatManageable)(target, manageScope)) {
+                    const requireRuntime = () => requireRuntimeFor(manageAccountId);
+                    /**
+                     * The scaffold every management action shares.
+                     *
+                     * Six actions used to spell it out one after another: resolve the
+                     * account, check the scope, log, answer a dry run, call the
+                     * runtime, log again, build the result. A change to any of those —
+                     * the dry-run contract, say — was a six-place edit in the plugin's
+                     * largest file, and the one deliberate exception (createGroup does
+                     * not check a chat scope, because the chat does not exist yet) was
+                     * invisible among the copies (finding A12-06).
+                     *
+                     * The differences stay written at each call site: what to parse,
+                     * what to log, what to run, what to answer. Only the scaffold moved.
+                     */
+                    const runManage = async (spec) => {
+                        const parsed = spec.parse();
+                        const target = spec.target(parsed);
+                        if (target === undefined) {
+                            // Nothing to check a scope against yet, so the gate is coarser:
+                            // management must be enabled at all for this account.
+                            if (!(0, manage_1.isManagementEnabled)(manageScope)) {
+                                actionLog.warn(`clawgram ${spec.name} refused: management is not enabled`, {
+                                    accountId: manageAccountId,
+                                });
+                                throw new Error("clawgram: chat management is not enabled for this account — "
+                                    + `set channels.clawgram.accounts.${manageAccountId}.manageChats`);
+                            }
+                        }
+                        else if (!(0, manage_1.isChatManageable)(target, manageScope)) {
                             actionLog.warn("clawgram management refused: chat outside manage scope", {
                                 accountId: manageAccountId,
                                 action: manageAction,
@@ -2180,188 +1089,126 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
                             });
                             throw new Error(`clawgram: not-managed-chat ${target}`);
                         }
-                    };
-                    const requireRuntime = () => {
-                        const gram = runtimes.get(manageAccountId);
-                        if (!gram) {
-                            throw new Error(`clawgram: runtime not found for account ${manageAccountId}`);
-                        }
-                        return gram;
-                    };
-                    if (manageAction === "createGroup") {
-                        const createParams = (0, manage_1.parseCreateGroupParams)(params);
-                        // A group being created is not in any scope yet, so the gate is
-                        // coarser: management must be enabled at all for this account.
-                        if (!(0, manage_1.isManagementEnabled)(manageScope)) {
-                            actionLog.warn("clawgram createGroup refused: management is not enabled", {
-                                accountId: manageAccountId,
-                            });
-                            throw new Error("clawgram: chat management is not enabled for this account — "
-                                + `set channels.clawgram.accounts.${manageAccountId}.manageChats`);
-                        }
-                        actionLog.info("clawgram handleAction createGroup", {
+                        actionLog.info(`clawgram handleAction ${spec.name}`, {
                             accountId: manageAccountId,
                             dryRun: dryRun === true,
-                            users: createParams.users.length,
-                            hasAbout: Boolean(createParams.about),
+                            ...spec.before(parsed),
                         });
                         if (dryRun === true) {
-                            return (0, core_1.jsonResult)({ ok: true, dryRun: true, accountId: manageAccountId });
+                            return (0, core_1.jsonResult)({
+                                ok: true,
+                                dryRun: true,
+                                accountId: manageAccountId,
+                                ...(target === undefined ? {} : { chatId: target }),
+                            });
                         }
-                        const created = await requireRuntime().createGroup(createParams);
-                        actionLog.info("clawgram handleAction createGroup completed", {
+                        const gram = requireRuntime();
+                        spec.precondition?.(gram);
+                        const result = await spec.run(gram, parsed);
+                        actionLog.info(`clawgram handleAction ${spec.name} completed`, {
                             accountId: manageAccountId,
-                            chatId: created.chatId ?? null,
-                            missing: created.missing.length,
+                            ...spec.after(parsed, result),
                         });
-                        return (0, core_1.jsonResult)({
-                            ok: true,
-                            accountId: manageAccountId,
-                            chatId: created.chatId,
-                            missing: created.missing,
+                        return (0, core_1.jsonResult)({ ok: true, accountId: manageAccountId, ...spec.result(parsed, result) });
+                    };
+                    if (manageAction === "createGroup") {
+                        return await runManage({
+                            name: "createGroup",
+                            parse: () => (0, manage_1.parseCreateGroupParams)(params),
+                            // A group being created is not in any scope yet.
+                            target: () => undefined,
+                            before: (p) => ({ users: p.users.length, hasAbout: Boolean(p.about) }),
+                            run: (gram, p) => gram.createGroup(p),
+                            after: (_p, created) => ({ chatId: created.chatId ?? null, missing: created.missing.length }),
+                            result: (_p, created) => ({ chatId: created.chatId, missing: created.missing }),
                         });
                     }
                     if (manageAction === "addMembers") {
-                        const addParams = (0, manage_1.parseAddMembersParams)(params, toolContext);
-                        requireManagedChat(addParams.target);
-                        actionLog.info("clawgram handleAction addMembers", {
-                            accountId: manageAccountId,
-                            dryRun: dryRun === true,
-                            target: addParams.target,
-                            users: addParams.users.length,
-                        });
-                        if (dryRun === true) {
-                            return (0, core_1.jsonResult)({ ok: true, dryRun: true, accountId: manageAccountId, chatId: addParams.target });
-                        }
-                        const added = await requireRuntime().addChatMembers(addParams);
-                        actionLog.info("clawgram handleAction addMembers completed", {
-                            accountId: manageAccountId,
-                            target: addParams.target,
-                            requested: addParams.users.length,
-                            missing: added.missing.length,
-                        });
-                        return (0, core_1.jsonResult)({
-                            ok: true,
-                            accountId: manageAccountId,
-                            chatId: added.chatId ?? addParams.target,
-                            requested: addParams.users.length,
-                            // Telegram refuses silently-restricted invites per user; the
-                            // caller gets the ids so it can hand them an invite link.
-                            missing: added.missing,
+                        return await runManage({
+                            name: "addMembers",
+                            parse: () => (0, manage_1.parseAddMembersParams)(params, toolContext),
+                            target: (p) => p.target,
+                            before: (p) => ({ target: p.target, users: p.users.length }),
+                            run: (gram, p) => gram.addChatMembers(p),
+                            after: (p, added) => ({
+                                target: p.target,
+                                requested: p.users.length,
+                                missing: added.missing.length,
+                            }),
+                            result: (p, added) => ({
+                                chatId: added.chatId ?? p.target,
+                                requested: p.users.length,
+                                // Telegram refuses silently-restricted invites per user; the
+                                // caller gets the ids so it can hand them an invite link.
+                                missing: added.missing,
+                            }),
                         });
                     }
                     if (manageAction === "removeMember") {
-                        const removeParams = (0, manage_1.parseRemoveMemberParams)(params, toolContext);
-                        requireManagedChat(removeParams.target);
-                        actionLog.info("clawgram handleAction removeMember", {
-                            accountId: manageAccountId,
-                            dryRun: dryRun === true,
-                            target: removeParams.target,
-                            ban: removeParams.ban,
-                        });
-                        if (dryRun === true) {
-                            return (0, core_1.jsonResult)({ ok: true, dryRun: true, accountId: manageAccountId, chatId: removeParams.target });
-                        }
-                        await requireRuntime().removeChatMember(removeParams);
-                        actionLog.info("clawgram handleAction removeMember completed", {
-                            accountId: manageAccountId,
-                            target: removeParams.target,
-                            ban: removeParams.ban,
-                        });
-                        return (0, core_1.jsonResult)({
-                            ok: true,
-                            accountId: manageAccountId,
-                            chatId: removeParams.target,
-                            user: removeParams.user,
-                            banned: removeParams.ban,
+                        return await runManage({
+                            name: "removeMember",
+                            parse: () => (0, manage_1.parseRemoveMemberParams)(params, toolContext),
+                            target: (p) => p.target,
+                            before: (p) => ({ target: p.target, ban: p.ban }),
+                            run: (gram, p) => gram.removeChatMember(p),
+                            after: (p) => ({ target: p.target, ban: p.ban }),
+                            result: (p) => ({ chatId: p.target, user: p.user, banned: p.ban }),
                         });
                     }
                     if (manageAction === "promoteAdmin" || manageAction === "demoteAdmin") {
-                        const adminParams = manageAction === "promoteAdmin"
-                            ? (0, manage_1.parsePromoteAdminParams)(params, toolContext)
-                            : (0, manage_1.parseDemoteAdminParams)(params, toolContext);
-                        requireManagedChat(adminParams.target);
-                        actionLog.info("clawgram handleAction setAdmin", {
-                            accountId: manageAccountId,
-                            dryRun: dryRun === true,
-                            target: adminParams.target,
-                            isAdmin: adminParams.isAdmin,
-                            hasRank: Boolean(adminParams.rank),
-                        });
-                        if (dryRun === true) {
-                            return (0, core_1.jsonResult)({ ok: true, dryRun: true, accountId: manageAccountId, chatId: adminParams.target });
-                        }
-                        await requireRuntime().setChatAdmin(adminParams);
-                        actionLog.info("clawgram handleAction setAdmin completed", {
-                            accountId: manageAccountId,
-                            target: adminParams.target,
-                            isAdmin: adminParams.isAdmin,
-                        });
-                        return (0, core_1.jsonResult)({
-                            ok: true,
-                            accountId: manageAccountId,
-                            chatId: adminParams.target,
-                            user: adminParams.user,
-                            isAdmin: adminParams.isAdmin,
-                            ...(adminParams.rank ? { rank: adminParams.rank } : {}),
+                        const promote = manageAction === "promoteAdmin";
+                        return await runManage({
+                            // Both spellings log as `setAdmin`, as they always have.
+                            name: "setAdmin",
+                            parse: () => (promote
+                                ? (0, manage_1.parsePromoteAdminParams)(params, toolContext)
+                                : (0, manage_1.parseDemoteAdminParams)(params, toolContext)),
+                            target: (p) => p.target,
+                            before: (p) => ({ target: p.target, isAdmin: p.isAdmin, hasRank: Boolean(p.rank) }),
+                            run: (gram, p) => gram.setChatAdmin(p),
+                            after: (p) => ({ target: p.target, isAdmin: p.isAdmin }),
+                            result: (p) => ({
+                                chatId: p.target,
+                                user: p.user,
+                                isAdmin: p.isAdmin,
+                                ...(p.rank ? { rank: p.rank } : {}),
+                            }),
                         });
                     }
                     if (manageAction === "transferOwnership") {
-                        const transferParams = (0, manage_1.parseTransferOwnershipParams)(params, toolContext);
-                        requireManagedChat(transferParams.target);
-                        actionLog.info("clawgram handleAction transferOwnership", {
-                            accountId: manageAccountId,
-                            dryRun: dryRun === true,
-                            target: transferParams.target,
-                        });
-                        if (dryRun === true) {
-                            return (0, core_1.jsonResult)({ ok: true, dryRun: true, accountId: manageAccountId, chatId: transferParams.target });
-                        }
-                        const transferGram = requireRuntime();
-                        // The password stays inside the runtime: it is read from the
-                        // account config at start-up and never travels through dispatch
-                        // arguments, which are one log call away from the journal.
-                        if (!transferGram.twoFaPassword) {
-                            throw new Error("clawgram: ownership transfer requires twoFaPassword in the account config "
-                                + "(the account's Telegram 2FA password, as a literal or a SecretRef)");
-                        }
-                        await transferGram.transferChatOwnership(transferParams);
-                        actionLog.info("clawgram handleAction transferOwnership completed", {
-                            accountId: manageAccountId,
-                            target: transferParams.target,
-                        });
-                        return (0, core_1.jsonResult)({
-                            ok: true,
-                            accountId: manageAccountId,
-                            chatId: transferParams.target,
-                            newOwner: transferParams.user,
+                        return await runManage({
+                            name: "transferOwnership",
+                            parse: () => (0, manage_1.parseTransferOwnershipParams)(params, toolContext),
+                            target: (p) => p.target,
+                            before: (p) => ({ target: p.target }),
+                            // The password stays inside the runtime: it is read from the
+                            // account config at start-up and never travels through dispatch
+                            // arguments, which are one log call away from the journal.
+                            precondition: (gram) => {
+                                if (!gram.twoFaPassword) {
+                                    throw new Error("clawgram: ownership transfer requires twoFaPassword in the account config "
+                                        + "(the account's Telegram 2FA password, as a literal or a SecretRef)");
+                                }
+                            },
+                            run: (gram, p) => gram.transferChatOwnership(p),
+                            after: (p) => ({ target: p.target }),
+                            result: (p) => ({ chatId: p.target, newOwner: p.user }),
                         });
                     }
                     // inviteLink — the only management action left.
-                    const inviteParams = (0, manage_1.parseInviteLinkParams)(params, toolContext);
-                    requireManagedChat(inviteParams.target);
-                    actionLog.info("clawgram handleAction inviteLink", {
-                        accountId: manageAccountId,
-                        dryRun: dryRun === true,
-                        target: inviteParams.target,
-                        hasExpiry: inviteParams.expireDate !== undefined,
-                        usageLimit: inviteParams.usageLimit ?? null,
-                        requestNeeded: inviteParams.requestNeeded,
-                    });
-                    if (dryRun === true) {
-                        return (0, core_1.jsonResult)({ ok: true, dryRun: true, accountId: manageAccountId, chatId: inviteParams.target });
-                    }
-                    const exported = await requireRuntime().exportChatInviteLink(inviteParams);
-                    actionLog.info("clawgram handleAction inviteLink completed", {
-                        accountId: manageAccountId,
-                        target: inviteParams.target,
-                        hasLink: Boolean(exported.link),
-                    });
-                    return (0, core_1.jsonResult)({
-                        ok: true,
-                        accountId: manageAccountId,
-                        chatId: inviteParams.target,
-                        link: exported.link,
+                    return await runManage({
+                        name: "inviteLink",
+                        parse: () => (0, manage_1.parseInviteLinkParams)(params, toolContext),
+                        target: (p) => p.target,
+                        before: (p) => ({
+                            target: p.target,
+                            hasExpiry: p.expireDate !== undefined,
+                            usageLimit: p.usageLimit ?? null,
+                            requestNeeded: p.requestNeeded,
+                        }),
+                        run: (gram, p) => gram.exportChatInviteLink(p),
+                        after: (p, exported) => ({ target: p.target, hasLink: Boolean(exported.link) }),
+                        result: (p, exported) => ({ chatId: p.target, link: exported.link }),
                     });
                 }
                 // Core normalizes whichever of these it filled in to a local path (see
@@ -2432,7 +1279,7 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
                         // the same prose as a message and renders identically.
                         parseMode: (0, helpers_1.resolveOutboundParseMode)(params, cfg, uploadAccountId),
                         replyToMessageId: (0, helpers_1.resolveReplyToMessageIdForTarget)(rawUploadTo, uploadReplyToId),
-                        messageThreadId: parseOptionalThreadId(uploadThreadId),
+                        messageThreadId: (0, helpers_1.parseOptionalThreadId)(uploadThreadId),
                         asVoice,
                     });
                     actionLog.info("clawgram handleAction upload-file completed", {
@@ -2455,7 +1302,7 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
                 const to = (0, helpers_1.normalizeOutboundTarget)(rawTo);
                 const replyToId = (0, param_readers_1.readStringOrNumberParam)(params, "replyToId") ?? (0, param_readers_1.readStringOrNumberParam)(params, "replyTo");
                 const threadId = (0, param_readers_1.readStringOrNumberParam)(params, "threadId");
-                const messageThreadId = parseOptionalThreadId(threadId);
+                const messageThreadId = (0, helpers_1.parseOptionalThreadId)(threadId);
                 // Omitting parseMode inherits the account's configured mode rather
                 // than falling back to plain text (2.13.0): an account set to `html`
                 // used to render replies as HTML and these sends as raw markup.
@@ -2607,245 +1454,7 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
                 });
             },
         },
-        outbound: {
-            // Core's agent-delivery path (`--deliver`, subagent announces) calls this
-            // hook under three constraints, all learned live on 2026-08-06:
-            //
-            // - `to` may be undefined (no explicit target, session route yielded
-            //   none), and a rejection is NOT caught: a throw here is an unhandled
-            //   rejection that takes down the entire gateway process.
-            // - `resolveAgentDeliveryPlanWithSessionRoute` calls it WITHOUT await.
-            //   An async hook hands core a Promise, `promise.ok` reads undefined and
-            //   the error branch dereferences `promise.error.message` — the crash
-            //   every subagent announce died on. The hook must return a plain value;
-            //   the call sites that do await are unaffected, await of a value works.
-            // - In a not-ok result core reads `error.message`, so the error must be
-            //   Error-like, not a bare string.
-            //
-            // Peer resolution deliberately does not happen here: `sendText` resolves
-            // the peer itself, and doing it here would force the hook async again.
-            resolveTarget(ctx) {
-                try {
-                    const raw = typeof ctx.to === "string" ? ctx.to.trim() : "";
-                    actionLog.info("clawgram outbound resolveTarget", {
-                        accountId: ctx.accountId,
-                        rawTo: raw || null,
-                    });
-                    if (!raw) {
-                        return { ok: false, error: new Error("clawgram: no delivery target — pass `to` or use a session with a bound chat") };
-                    }
-                    const target = (0, helpers_1.normalizeOutboundTarget)(raw);
-                    // Тот же барьер, что у `handleAction`: доставка ядра (`--deliver`,
-                    // анонсы субагентов) идёт этим путём и мимо той проверки. Отказ
-                    // здесь возвращается результатом, а не броском: бросок в этом хуке
-                    // роняет весь gateway (грабли 06.08.2026, выше).
-                    if (!(0, send_scope_1.isChatSendable)(target, (0, send_scope_1.sendScopeFor)(ctx.accountId))) {
-                        const reason = (0, send_scope_1.isPhoneNumberTarget)(target)
-                            ? "phone-number target"
-                            : "chat outside send scope";
-                        actionLog.warn("clawgram outbound resolveTarget refused", {
-                            accountId: ctx.accountId,
-                            target,
-                            reason,
-                        });
-                        return { ok: false, error: new Error(`clawgram: not-allowed-chat ${target}`) };
-                    }
-                    return { ok: true, to: target };
-                }
-                catch (err) {
-                    return { ok: false, error: err instanceof Error ? err : new Error(String(err)) };
-                }
-            },
-            async sendText(ctx) {
-                // Never log `text`: outbound bodies are private correspondence and the
-                // channel log is a plain journald sink. Length is enough to tell an
-                // empty or truncated send apart from a real one.
-                actionLog.info("clawgram outbound sendText", {
-                    accountId: ctx.accountId,
-                    rawTo: ctx.to,
-                    replyToId: ctx.replyToId ?? null,
-                    threadId: ctx.threadId ?? null,
-                    textLength: ctx.text.length,
-                });
-                // Core normalizes reply payloads and drops the silent token before a
-                // channel is called, so this should never see one. "Should never" is
-                // what the inbound path was assumed to be too, right until it posted a
-                // token — and the check costs a string comparison.
-                if (ctx.text.trim() && (0, helpers_1.isSilentReplyText)(ctx.text)) {
-                    actionLog.info("clawgram suppressing silent outbound send", {
-                        accountId: ctx.accountId,
-                        rawTo: ctx.to,
-                    });
-                    return { skipped: "silent" };
-                }
-                // Core's operational chatter (tool-error warnings, fallback notices)
-                // stays out of group chats: it is telemetry for the operator, not a
-                // reply to the room, and it has already been seen carrying shell
-                // commands with secret-store paths. DMs keep it. The text itself is
-                // never logged — see system-notice.ts for why.
-                const suppressedNotice = (0, system_notice_1.shouldSuppressGroupSystemNotice)({
-                    targetKind: (0, helpers_1.inferOutboundTargetKind)(ctx.to),
-                    text: ctx.text,
-                    to: ctx.to,
-                    operatorIds: (0, system_notice_1.operatorIdsFor)(ctx.accountId),
-                });
-                if (suppressedNotice) {
-                    actionLog.warn("clawgram suppressing system notice in group", {
-                        accountId: ctx.accountId,
-                        rawTo: ctx.to,
-                        noticeKind: suppressedNotice,
-                        textLength: ctx.text.length,
-                    });
-                    return { skipped: "system-notice" };
-                }
-                const gram = runtimes.get(ctx.accountId);
-                if (!gram) {
-                    throw new Error(`clawgram: runtime not found for account ${ctx.accountId}`);
-                }
-                // The agent already answered this message with its own `send`, and this
-                // is core delivering the same turn's final text. Two messages for one
-                // answer is how 2026-08-10 read in a work chat: every request reported
-                // twice, in slightly different words, seconds apart.
-                //
-                // Core's own convention is that an agent which has sent a message
-                // returns NO_REPLY; this catches the turns that forget. The window is
-                // seconds wide, so a result the assistant comes back with later is
-                // still delivered.
-                if (ctx.replyToId !== null && ctx.replyToId !== undefined && (0, group_visible_reply_guard_1.hadTurnSendJustNow)({
-                    accountId: ctx.accountId,
-                    chatId: (0, helpers_1.normalizeOutboundTarget)(ctx.to),
-                    currentMessageId: ctx.replyToId,
-                })) {
-                    actionLog.warn("clawgram suppressing echo of a turn that already sent", {
-                        accountId: ctx.accountId,
-                        rawTo: ctx.to,
-                        replyToId: ctx.replyToId,
-                        textLength: ctx.text.length,
-                    });
-                    return { skipped: "duplicate" };
-                }
-                const groupReplyAddress = (0, group_reply_address_1.consumeGroupReplyAddress)({
-                    accountId: ctx.accountId,
-                    chatId: ctx.to,
-                    replyToId: ctx.replyToId,
-                });
-                const targetKind = (0, helpers_1.inferOutboundTargetKind)(ctx.to);
-                const target = (0, helpers_1.normalizeOutboundTarget)(ctx.to);
-                const messageThreadId = parseOptionalThreadId(ctx.threadId);
-                const sent = await gram.sendText({
-                    target,
-                    text: (0, helpers_1.prefixReplyTextToAddress)(ctx.text, groupReplyAddress),
-                    targetKind,
-                    replyToMessageId: (0, helpers_1.resolveReplyToMessageIdForTarget)(ctx.to, ctx.replyToId),
-                    messageThreadId,
-                    parseMode: gram.replyParseMode,
-                });
-                actionLog.info("clawgram outbound sendText completed", {
-                    accountId: ctx.accountId,
-                    to: target,
-                    targetKind,
-                    replyToId: ctx.replyToId ?? null,
-                    sentMessageId: String(sent?.id ?? ""),
-                });
-                return {
-                    ok: true,
-                    messageId: String(sent?.id ?? ""),
-                };
-            },
-            async sendMedia(ctx) {
-                const gram = runtimes.get(ctx.accountId);
-                if (!gram) {
-                    throw new Error(`clawgram: runtime not found for account ${ctx.accountId}`);
-                }
-                // Same rule as the action path: a local file outside the declared
-                // roots is refused before anything is uploaded.
-                const outboundRoots = ctx.mediaLocalRoots ?? ctx.mediaAccess?.localRoots;
-                (0, media_1.assertLocalMediaWithinRoots)(ctx.filePath, outboundRoots);
-                (0, media_1.assertLocalMediaWithinRoots)(ctx.mediaUrl, outboundRoots);
-                actionLog.info("clawgram outbound sendMedia", {
-                    accountId: ctx.accountId,
-                    rawTo: ctx.to,
-                    replyToId: ctx.replyToId ?? null,
-                    threadId: ctx.threadId ?? null,
-                    filePath: ctx.filePath ?? null,
-                    mediaUrl: ctx.mediaUrl ?? null,
-                    hasText: Boolean(ctx.text),
-                    hasCaption: Boolean(ctx.caption),
-                    asVoice: ctx.audioAsVoice === true,
-                });
-                const file = ctx.filePath ?? ctx.mediaUrl;
-                if (!file) {
-                    throw new Error("clawgram: sendMedia requires filePath or mediaUrl");
-                }
-                // Ниже — проверки, которые у `sendText` были, а здесь не было ни
-                // одной: путь доставки медиа писался отдельно и обзавёлся только
-                // своими границами (находка A6-18).
-                const mediaTarget = (0, helpers_1.normalizeOutboundTarget)(ctx.to);
-                // Область отправки: файл наружу — такое же исходящее, как текст.
-                // `resolveTarget` ядро зовёт не на каждом пути, поэтому проверяем и тут.
-                if (!(0, send_scope_1.isChatSendable)(mediaTarget, (0, send_scope_1.sendScopeFor)(ctx.accountId))) {
-                    actionLog.warn("clawgram outbound sendMedia refused", {
-                        accountId: ctx.accountId,
-                        target: mediaTarget,
-                        reason: (0, send_scope_1.isPhoneNumberTarget)(mediaTarget) ? "phone-number target" : "chat outside send scope",
-                    });
-                    return { skipped: "not-allowed" };
-                }
-                // Молчаливый ответ: подпись с токеном молчания означает «ничего не
-                // говорить», и отправлять файл с ним в подписи — тем более.
-                const mediaCaption = ctx.caption ?? ctx.text;
-                if (mediaCaption?.trim() && (0, helpers_1.isSilentReplyText)(mediaCaption)) {
-                    actionLog.info("clawgram suppressing silent outbound media", {
-                        accountId: ctx.accountId,
-                        rawTo: ctx.to,
-                    });
-                    return { skipped: "silent" };
-                }
-                // Обращение в группе — то же, что у текста: адрес принадлежит
-                // конкретному входящему сообщению, а не последнему говорившему.
-                const mediaReplyAddress = (0, group_reply_address_1.consumeGroupReplyAddress)({
-                    accountId: ctx.accountId,
-                    chatId: ctx.to,
-                    replyToId: ctx.replyToId,
-                });
-                // Чего здесь НЕТ намеренно:
-                // — подавление эха хода (`hadTurnSendJustNow`): у текста дубль стоит
-                //   лишнего сообщения, а у медиа отказ стоит потерянного файла —
-                //   картинку агент готовил, и второй раз она не появится;
-                // — подавление служебных сообщений ядра в группах: они текстовые,
-                //   медиа-доставка ими не бывает.
-                const messageThreadId = parseOptionalThreadId(ctx.threadId);
-                // Same normalization `sendText` does two functions up. Without it the
-                // channel prefix reaches peer resolution and the send throws — which is
-                // exactly how a synthesized group reply died on 2026-08-08, silently
-                // enough that the transcript fallback posted it as raw text instead.
-                const target = (0, helpers_1.normalizeOutboundTarget)(ctx.to);
-                const sent = await gram.sendMedia({
-                    target,
-                    file,
-                    // Подпись получает то же обращение, что и текстовый ответ.
-                    caption: mediaCaption
-                        ? (0, helpers_1.prefixReplyTextToAddress)(mediaCaption, mediaReplyAddress)
-                        : mediaCaption,
-                    // Captions follow the account reply format like every other reply:
-                    // they are the same agent prose, just attached to a file (2.15.0).
-                    parseMode: gram.replyParseMode,
-                    replyToMessageId: (0, helpers_1.resolveReplyToMessageIdForTarget)(ctx.to, ctx.replyToId),
-                    messageThreadId,
-                    asVoice: ctx.audioAsVoice === true,
-                });
-                actionLog.info("clawgram outbound sendMedia completed", {
-                    accountId: ctx.accountId,
-                    to: ctx.to,
-                    replyToId: ctx.replyToId ?? null,
-                    sentMessageId: String(sent?.id ?? ""),
-                });
-                return {
-                    ok: true,
-                    messageId: String(sent?.id ?? ""),
-                };
-            },
-        },
+        outbound: (0, outbound_1.createOutbound)(runtimes),
     };
 };
 exports.createChannelPlugin = createChannelPlugin;