@holon-run/agentinbox 0.7.0 → 1.0.0-beta.0

package/dist/src/source_hosts.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSourceRegistration = resolveSourceRegistration;
+function resolveSourceRegistration(input) {
+    const config = input.config ?? {};
+    if (input.sourceType === "github_repo") {
+        return {
+            hostType: "github",
+            hostKey: `uxcAuth:${stringOrDefault(config.uxcAuth, input.configRef ?? "default")}`,
+            hostConfig: {
+                ...(valueOrUndefined(config.uxcAuth) ? { uxcAuth: config.uxcAuth } : {}),
+            },
+            streamKind: "repo_events",
+            streamKey: input.sourceKey,
+            streamConfig: config,
+            sourceType: input.sourceType,
+        };
+    }
+    if (input.sourceType === "github_repo_ci") {
+        return {
+            hostType: "github",
+            hostKey: `uxcAuth:${stringOrDefault(config.uxcAuth, input.configRef ?? "default")}`,
+            hostConfig: {
+                ...(valueOrUndefined(config.uxcAuth) ? { uxcAuth: config.uxcAuth } : {}),
+            },
+            streamKind: "ci_runs",
+            streamKey: input.sourceKey,
+            streamConfig: config,
+            sourceType: input.sourceType,
+        };
+    }
+    if (input.sourceType === "feishu_bot") {
+        return {
+            hostType: "feishu",
+            hostKey: `app:${stringOrDefault(config.appId, input.configRef ?? input.sourceKey)}`,
+            hostConfig: {
+                ...(valueOrUndefined(config.appId) ? { appId: config.appId } : {}),
+                ...(valueOrUndefined(config.appSecret) ? { appSecret: config.appSecret } : {}),
+                ...(valueOrUndefined(config.schemaUrl) ? { schemaUrl: config.schemaUrl } : {}),
+                ...(valueOrUndefined(config.replyInThread) ? { replyInThread: config.replyInThread } : {}),
+                ...(valueOrUndefined(config.uxcAuth) ? { uxcAuth: config.uxcAuth } : {}),
+            },
+            streamKind: "message_events",
+            streamKey: input.sourceKey,
+            streamConfig: config,
+            sourceType: input.sourceType,
+        };
+    }
+    if (input.sourceType === "local_event") {
+        return {
+            hostType: "local_event",
+            hostKey: input.sourceKey,
+            hostConfig: {},
+            streamKind: "events",
+            streamKey: input.sourceKey,
+            streamConfig: config,
+            sourceType: input.sourceType,
+        };
+    }
+    return {
+        hostType: "remote_source",
+        hostKey: input.sourceKey,
+        hostConfig: config,
+        streamKind: "default",
+        streamKey: input.sourceKey,
+        streamConfig: config,
+        sourceType: input.sourceType,
+    };
+}
+function stringOrDefault(value, fallback) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : fallback;
+}
+function valueOrUndefined(value) {
+    return value !== undefined && value !== null;
+}

package/dist/src/source_resolution.js

@@ -25,7 +25,7 @@ async function resolveSourceIdentity(source, context = {}) {
     if (source.sourceType !== "remote_source") {
         throw new Error(`unsupported source type for source resolution: ${source.sourceType}`);
     }
-    const moduleRegistry = context.moduleRegistry ?? context.profileRegistry ?? new remote_modules_1.RemoteSourceModuleRegistry();
+    const moduleRegistry = context.moduleRegistry ?? new remote_modules_1.RemoteSourceModuleRegistry();
     const homeDir = context.homeDir ?? (0, paths_1.resolveAgentInboxHome)(process.env);
     const module = await moduleRegistry.resolve(source, homeDir);
     const capabilityDescription = typeof module.describeCapabilities === "function"
@@ -38,7 +38,7 @@ async function resolveSourceIdentity(source, context = {}) {
     };
 }
 async function resolveSourceSchema(source, context = {}) {
-    const moduleRegistry = context.moduleRegistry ?? context.profileRegistry ?? new remote_modules_1.RemoteSourceModuleRegistry();
+    const moduleRegistry = context.moduleRegistry ?? new remote_modules_1.RemoteSourceModuleRegistry();
     const homeDir = context.homeDir ?? (0, paths_1.resolveAgentInboxHome)(process.env);
     const resolvedContext = { ...context, moduleRegistry, homeDir };
     const identity = await resolveSourceIdentity(source, resolvedContext);

package/dist/src/source_schema.js

@@ -21,8 +21,8 @@ const SOURCE_SCHEMAS = {
         payloadExamples: [],
         eventVariantExamples: [],
         configFields: [
-            { name: "profilePath", type: "string", required: true, description: "Local module path under $AGENTINBOX_HOME/source-profiles." },
-            { name: "profileConfig", type: "object", required: false, description: "Module-specific configuration passed to validate/spec/map hooks." },
+            { name: "modulePath", type: "string", required: true, description: "Local module path under $AGENTINBOX_HOME/source-modules." },
+            { name: "moduleConfig", type: "object", required: false, description: "Module-specific configuration passed to validate/spec/map hooks." },
         ],
     },
     github_repo: {

package/dist/src/sources/feishu.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FeishuDeliveryAdapter = exports.FeishuUxcClient = exports.DEFAULT_FEISHU_EVENT_TYPES = exports.FEISHU_IM_SCHEMA_URL = exports.FEISHU_OPENAPI_ENDPOINT = void 0;
+exports.feishuDeliveryOperationsForHandle = feishuDeliveryOperationsForHandle;
+exports.invokeFeishuDeliveryOperation = invokeFeishuDeliveryOperation;
 exports.normalizeFeishuBotEvent = normalizeFeishuBotEvent;
 exports.parseFeishuSourceConfig = parseFeishuSourceConfig;
 const uxc_daemon_client_1 = require("@holon-run/uxc-daemon-client");
@@ -54,37 +56,73 @@ class FeishuDeliveryAdapter {
         this.client = client ?? new FeishuUxcClient();
     }
     async send(request, attempt) {
-        const config = parseDeliveryConfig(request.payload);
-        const message = normalizeDeliveryMessage(request.payload);
-        if (attempt.surface === "message_reply") {
-            await this.client.replyToMessage({
-                endpoint: config.endpoint,
-                schemaUrl: config.schemaUrl,
-                auth: config.auth,
-                messageId: attempt.targetRef,
-                msgType: message.msgType,
-                content: message.content,
-                replyInThread: config.replyInThread,
-                uuid: config.uuid,
-            });
-            return { status: "sent", note: "sent Feishu message reply" };
-        }
-        if (attempt.surface === "chat_message") {
-            await this.client.sendChatMessage({
-                endpoint: config.endpoint,
-                schemaUrl: config.schemaUrl,
-                auth: config.auth,
-                chatId: attempt.targetRef,
-                msgType: message.msgType,
-                content: message.content,
-                uuid: config.uuid,
-            });
-            return { status: "sent", note: "sent Feishu chat message" };
-        }
-        throw new Error(`unsupported Feishu surface: ${attempt.surface}`);
+        return invokeFeishuDeliveryOperation(attempt, "send_text", request.payload, this.client);
     }
 }
 exports.FeishuDeliveryAdapter = FeishuDeliveryAdapter;
+function feishuDeliveryOperationsForHandle(handle) {
+    if (handle.surface !== "message_reply" && handle.surface !== "chat_message") {
+        return [];
+    }
+    return [{
+            name: "send_text",
+            title: handle.surface === "message_reply" ? "Reply With Text" : "Send Text Message",
+            inputSchema: {
+                type: "object",
+                additionalProperties: false,
+                required: ["text"],
+                properties: {
+                    text: { type: "string", minLength: 1 },
+                    endpoint: { type: "string", minLength: 1 },
+                    schemaUrl: { type: "string", minLength: 1 },
+                    schema_url: { type: "string", minLength: 1 },
+                    uxcAuth: { type: "string", minLength: 1 },
+                    auth: { type: "string", minLength: 1 },
+                    replyInThread: { type: "boolean" },
+                    reply_in_thread: { type: "boolean" },
+                    uuid: { type: "string", minLength: 1 },
+                },
+            },
+            canonicalTextAlias: true,
+        }];
+}
+async function invokeFeishuDeliveryOperation(handle, operation, input, client = new FeishuUxcClient()) {
+    if (operation !== "send_text") {
+        throw new Error(`unknown Feishu delivery operation: ${operation}`);
+    }
+    const text = asString(input.text);
+    if (!text || text.trim().length === 0) {
+        throw new Error("send_text requires input.text");
+    }
+    const config = parseDeliveryConfig(input);
+    const message = normalizeDeliveryMessage({ text });
+    if (handle.surface === "message_reply") {
+        await client.replyToMessage({
+            endpoint: config.endpoint,
+            schemaUrl: config.schemaUrl,
+            auth: config.auth,
+            messageId: handle.targetRef,
+            msgType: message.msgType,
+            content: message.content,
+            replyInThread: config.replyInThread,
+            uuid: config.uuid,
+        });
+        return { status: "sent", note: "sent Feishu message reply" };
+    }
+    if (handle.surface === "chat_message") {
+        await client.sendChatMessage({
+            endpoint: config.endpoint,
+            schemaUrl: config.schemaUrl,
+            auth: config.auth,
+            chatId: handle.targetRef,
+            msgType: message.msgType,
+            content: message.content,
+            uuid: config.uuid,
+        });
+        return { status: "sent", note: "sent Feishu chat message" };
+    }
+    throw new Error(`deliver send only supports canonical Feishu text surfaces; use deliver invoke for ${handle.surface}`);
+}
 function normalizeFeishuBotEvent(source, config, raw) {
     if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
         return null;

package/dist/src/sources/github.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GithubDeliveryAdapter = exports.GithubUxcClient = exports.DEFAULT_GITHUB_EVENT_TYPES = exports.GITHUB_ENDPOINT = void 0;
+exports.githubDeliveryOperationsForHandle = githubDeliveryOperationsForHandle;
+exports.invokeGithubDeliveryOperation = invokeGithubDeliveryOperation;
 exports.normalizeGithubRepoEvent = normalizeGithubRepoEvent;
 exports.deriveGithubTrackedResource = deriveGithubTrackedResource;
 exports.githubSubscriptionShortcutSpec = githubSubscriptionShortcutSpec;
@@ -48,6 +50,34 @@ class GithubUxcClient {
             options: { auth: input.auth },
         });
     }
+    async updateIssueState(input) {
+        await this.client.call({
+            endpoint: exports.GITHUB_ENDPOINT,
+            operation: "patch:/repos/{owner}/{repo}/issues/{issue_number}",
+            payload: {
+                owner: input.owner,
+                repo: input.repo,
+                issue_number: input.issueNumber,
+                state: input.state,
+            },
+            options: { auth: input.auth },
+        });
+    }
+    async mergePullRequest(input) {
+        await this.client.call({
+            endpoint: exports.GITHUB_ENDPOINT,
+            operation: "put:/repos/{owner}/{repo}/pulls/{pull_number}/merge",
+            payload: {
+                owner: input.owner,
+                repo: input.repo,
+                pull_number: input.pullNumber,
+                merge_method: input.mergeMethod ?? null,
+                commit_title: input.commitTitle ?? null,
+                commit_message: input.commitMessage ?? null,
+            },
+            options: { auth: input.auth },
+        });
+    }
 }
 exports.GithubUxcClient = GithubUxcClient;
 class GithubDeliveryAdapter {
@@ -57,33 +87,131 @@ class GithubDeliveryAdapter {
     }
     async send(request, attempt) {
         const payloadText = stringifyDeliveryPayload(request.payload);
-        const target = parseTargetRef(attempt.targetRef);
-        if (attempt.surface === "issue_comment" || attempt.surface === "pull_request_comment") {
-            await this.client.createIssueComment({
-                owner: target.owner,
-                repo: target.repo,
-                issueNumber: target.number,
-                body: payloadText,
-            });
-            return { status: "sent", note: "sent GitHub issue comment" };
-        }
-        if (attempt.surface === "review_comment") {
-            if (!attempt.threadRef || !attempt.threadRef.startsWith("review_comment:")) {
-                throw new Error("review_comment delivery requires threadRef=review_comment:<id>");
-            }
-            await this.client.replyToReviewComment({
-                owner: target.owner,
-                repo: target.repo,
-                pullNumber: target.number,
-                commentId: Number(attempt.threadRef.slice("review_comment:".length)),
-                body: payloadText,
-            });
-            return { status: "sent", note: "sent GitHub review comment reply" };
-        }
-        throw new Error(`unsupported GitHub surface: ${attempt.surface}`);
+        return invokeGithubDeliveryOperation(attempt, canonicalGithubOperationForSurface(attempt.surface), { body: payloadText }, this.client);
     }
 }
 exports.GithubDeliveryAdapter = GithubDeliveryAdapter;
+function githubDeliveryOperationsForHandle(handle) {
+    if (handle.surface === "review_comment") {
+        return [{
+                name: "reply_in_review_thread",
+                title: "Reply In Review Thread",
+                inputSchema: deliveryBodySchema(),
+                canonicalTextAlias: true,
+            }];
+    }
+    if (handle.surface === "issue_comment") {
+        return [
+            {
+                name: "add_comment",
+                title: "Add Comment",
+                inputSchema: deliveryBodySchema(),
+                canonicalTextAlias: true,
+            },
+            {
+                name: "close_issue",
+                title: "Close Issue",
+                inputSchema: emptyObjectSchema(),
+            },
+            {
+                name: "reopen_issue",
+                title: "Reopen Issue",
+                inputSchema: emptyObjectSchema(),
+            },
+        ];
+    }
+    if (handle.surface === "pull_request_comment") {
+        return [
+            {
+                name: "add_comment",
+                title: "Add Comment",
+                inputSchema: deliveryBodySchema(),
+                canonicalTextAlias: true,
+            },
+            {
+                name: "close_issue",
+                title: "Close Pull Request",
+                inputSchema: emptyObjectSchema(),
+            },
+            {
+                name: "reopen_issue",
+                title: "Reopen Pull Request",
+                inputSchema: emptyObjectSchema(),
+            },
+            {
+                name: "merge_pull_request",
+                title: "Merge Pull Request",
+                inputSchema: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        mergeMethod: { type: "string", enum: ["merge", "squash", "rebase"] },
+                        commitTitle: { type: "string" },
+                        commitMessage: { type: "string" },
+                    },
+                },
+            },
+        ];
+    }
+    return [];
+}
+async function invokeGithubDeliveryOperation(handle, operation, input, client = new GithubUxcClient()) {
+    const target = parseTargetRef(handle.targetRef);
+    if (operation === "add_comment") {
+        const body = requireDeliveryBody(input, operation);
+        await client.createIssueComment({
+            owner: target.owner,
+            repo: target.repo,
+            issueNumber: target.number,
+            body,
+        });
+        return { status: "sent", note: "sent GitHub issue comment" };
+    }
+    if (operation === "reply_in_review_thread") {
+        const body = requireDeliveryBody(input, operation);
+        if (!handle.threadRef || !handle.threadRef.startsWith("review_comment:")) {
+            throw new Error("reply_in_review_thread requires threadRef=review_comment:<id>");
+        }
+        await client.replyToReviewComment({
+            owner: target.owner,
+            repo: target.repo,
+            pullNumber: target.number,
+            commentId: Number(handle.threadRef.slice("review_comment:".length)),
+            body,
+        });
+        return { status: "sent", note: "sent GitHub review comment reply" };
+    }
+    if (operation === "close_issue") {
+        await client.updateIssueState({
+            owner: target.owner,
+            repo: target.repo,
+            issueNumber: target.number,
+            state: "closed",
+        });
+        return { status: "sent", note: "closed GitHub issue" };
+    }
+    if (operation === "reopen_issue") {
+        await client.updateIssueState({
+            owner: target.owner,
+            repo: target.repo,
+            issueNumber: target.number,
+            state: "open",
+        });
+        return { status: "sent", note: "reopened GitHub issue" };
+    }
+    if (operation === "merge_pull_request") {
+        await client.mergePullRequest({
+            owner: target.owner,
+            repo: target.repo,
+            pullNumber: target.number,
+            mergeMethod: asMergeMethod(input.mergeMethod),
+            commitTitle: asString(input.commitTitle) ?? undefined,
+            commitMessage: asString(input.commitMessage) ?? undefined,
+        });
+        return { status: "sent", note: "merged GitHub pull request" };
+    }
+    throw new Error(`unknown GitHub delivery operation: ${operation}`);
+}
 function normalizeGithubRepoEvent(source, config, raw) {
     if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
         return null;
@@ -300,6 +428,42 @@ function stringifyDeliveryPayload(payload) {
     }
     return JSON.stringify(payload, null, 2);
 }
+function canonicalGithubOperationForSurface(surface) {
+    if (surface === "issue_comment" || surface === "pull_request_comment") {
+        return "add_comment";
+    }
+    if (surface === "review_comment") {
+        return "reply_in_review_thread";
+    }
+    throw new Error(`deliver send only supports canonical GitHub text surfaces; use deliver invoke for ${surface}`);
+}
+function deliveryBodySchema() {
+    return {
+        type: "object",
+        additionalProperties: false,
+        required: ["body"],
+        properties: {
+            body: { type: "string", minLength: 1 },
+        },
+    };
+}
+function emptyObjectSchema() {
+    return {
+        type: "object",
+        additionalProperties: false,
+        properties: {},
+    };
+}
+function requireDeliveryBody(input, operation) {
+    const body = asString(input.body);
+    if (!body || body.trim().length === 0) {
+        throw new Error(`${operation} requires input.body`);
+    }
+    return body;
+}
+function asMergeMethod(value) {
+    return value === "merge" || value === "squash" || value === "rebase" ? value : undefined;
+}
 function asRecord(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         return {};

package/dist/src/sources/remote.js

@@ -65,7 +65,7 @@ class RemoteSourceRuntime {
     constructor(store, appendSourceEvent, options) {
         this.store = store;
         this.appendSourceEvent = appendSourceEvent;
-        this.moduleRegistry = options?.moduleRegistry ?? options?.profileRegistry ?? new remote_modules_1.RemoteSourceModuleRegistry();
+        this.moduleRegistry = options?.moduleRegistry ?? new remote_modules_1.RemoteSourceModuleRegistry();
         this.client = options?.client ?? new RpcUxcRemoteSourceClient();
         this.homeDir = options?.homeDir ?? (0, paths_1.resolveAgentInboxHome)(process.env);
     }
@@ -201,6 +201,26 @@ class RemoteSourceRuntime {
         }
         return module.deriveInlinePreview(item, moduleInputSource(source));
     }
+    async deriveNotificationGrouping(source, item) {
+        if (!REMOTE_SOURCE_TYPES.has(source.sourceType)) {
+            return null;
+        }
+        const module = await this.moduleRegistry.resolve(source, this.homeDir);
+        if (typeof module.deriveNotificationGrouping !== "function") {
+            return null;
+        }
+        return module.deriveNotificationGrouping(item, moduleInputSource(source));
+    }
+    async summarizeDigestThread(source, items, grouping) {
+        if (!REMOTE_SOURCE_TYPES.has(source.sourceType)) {
+            return null;
+        }
+        const module = await this.moduleRegistry.resolve(source, this.homeDir);
+        if (typeof module.summarizeDigestThread !== "function") {
+            return null;
+        }
+        return module.summarizeDigestThread(items, moduleInputSource(source), grouping);
+    }
     async syncAll() {
         const sources = this.store
             .listSources()
@@ -355,7 +375,7 @@ function moduleInputSource(source) {
     const config = asRecord(source.config);
     return {
         ...source,
-        config: asRecord(config.profileConfig),
+        config: asRecord(config.moduleConfig),
     };
 }
 function defaultManagedBindingForSource(source) {

package/dist/src/sources/remote_modules.js

@@ -12,7 +12,7 @@ const node_url_1 = require("node:url");
 const github_1 = require("./github");
 const github_ci_1 = require("./github_ci");
 const feishu_1 = require("./feishu");
-const REMOTE_USER_MODULE_ROOT_DIR = "source-profiles";
+const REMOTE_USER_MODULE_ROOT_DIR = "source-modules";
 const BUILTIN_MODULE_IDS = new Set(["builtin.github_repo", "builtin.github_repo_ci", "builtin.feishu_bot"]);
 class RemoteSourceModuleRegistry {
     moduleCache = new Map();
@@ -33,12 +33,12 @@ class RemoteSourceModuleRegistry {
     }
     async loadUserModule(source, homeDir) {
         const config = source.config ?? {};
-        const profilePath = asNonEmptyString(config.profilePath);
-        if (!profilePath) {
-            throw new Error("remote_source requires config.profilePath (module path)");
+        const modulePath = asNonEmptyString(config.modulePath);
+        if (!modulePath) {
+            throw new Error("remote_source requires config.modulePath (module path)");
         }
         const moduleRoot = node_path_1.default.resolve(homeDir, REMOTE_USER_MODULE_ROOT_DIR);
-        const resolvedPath = resolveAndValidateModulePath(moduleRoot, profilePath);
+        const resolvedPath = resolveAndValidateModulePath(moduleRoot, modulePath);
         const cacheKey = `${resolvedPath}:${source.sourceKey}`;
         const cached = this.moduleCache.get(cacheKey);
         if (cached) {
@@ -96,20 +96,24 @@ function validateModuleContract(module, sourcePath) {
     validateOptionalHook(module.deriveTrackedResource, "deriveTrackedResource", sourcePath);
     validateOptionalHook(module.projectLifecycleSignal, "projectLifecycleSignal", sourcePath);
     validateOptionalHook(module.deriveInlinePreview, "deriveInlinePreview", sourcePath);
+    validateOptionalHook(module.deriveNotificationGrouping, "deriveNotificationGrouping", sourcePath);
+    validateOptionalHook(module.listDeliveryOperations, "listDeliveryOperations", sourcePath);
+    validateOptionalHook(module.invokeDeliveryOperation, "invokeDeliveryOperation", sourcePath);
+    validateOptionalHook(module.summarizeDigestThread, "summarizeDigestThread", sourcePath);
 }
 function validateOptionalHook(value, name, sourcePath) {
     if (value !== undefined && typeof value !== "function") {
         throw new Error(`remote_source module ${name} must be a function when provided: ${sourcePath}`);
     }
 }
-function resolveAndValidateModulePath(moduleRoot, profilePath) {
-    const resolved = node_path_1.default.isAbsolute(profilePath)
-        ? node_path_1.default.resolve(profilePath)
-        : node_path_1.default.resolve(moduleRoot, profilePath);
+function resolveAndValidateModulePath(moduleRoot, modulePath) {
+    const resolved = node_path_1.default.isAbsolute(modulePath)
+        ? node_path_1.default.resolve(modulePath)
+        : node_path_1.default.resolve(moduleRoot, modulePath);
     const normalizedRoot = ensureTrailingSep(node_path_1.default.resolve(moduleRoot));
     const normalizedResolved = node_path_1.default.resolve(resolved);
     if (!normalizedResolved.startsWith(normalizedRoot) && normalizedResolved !== node_path_1.default.resolve(moduleRoot)) {
-        throw new Error(`remote_source profilePath must stay under ${moduleRoot}`);
+        throw new Error(`remote_source modulePath must stay under ${moduleRoot}`);
     }
     return normalizedResolved;
 }
@@ -131,6 +135,12 @@ function asNonEmptyString(value) {
 }
 const GITHUB_REPO_MODULE = {
     id: "builtin.github_repo",
+    listDeliveryOperations(input) {
+        return (0, github_1.githubDeliveryOperationsForHandle)(input.handle);
+    },
+    async invokeDeliveryOperation(input) {
+        return (0, github_1.invokeGithubDeliveryOperation)(input.handle, input.operation, input.input);
+    },
     describeCapabilities(source) {
         const config = (0, github_1.parseGithubSourceConfig)(source);
         return {
@@ -193,6 +203,54 @@ const GITHUB_REPO_MODULE = {
     deriveTrackedResource(filter) {
         return (0, github_1.deriveGithubTrackedResource)(filter);
     },
+    deriveNotificationGrouping(item) {
+        const number = typeof item.metadata.number === "number" ? item.metadata.number : null;
+        if (!number) {
+            return null;
+        }
+        const variant = item.eventVariant;
+        if (variant.startsWith("PullRequestReviewCommentEvent.")) {
+            return {
+                groupable: true,
+                resourceRef: `pr:${number}`,
+                eventFamily: "review_comments",
+                summaryHint: `review comments on PR #${number}`,
+            };
+        }
+        if (variant.startsWith("PullRequestReviewEvent.")) {
+            return {
+                groupable: true,
+                resourceRef: `pr:${number}`,
+                eventFamily: "reviews",
+                summaryHint: `reviews on PR #${number}`,
+            };
+        }
+        if (variant.startsWith("IssueCommentEvent.")) {
+            return {
+                groupable: true,
+                resourceRef: item.metadata.isPullRequest === true ? `pr:${number}` : `issue:${number}`,
+                eventFamily: "comments",
+                summaryHint: item.metadata.isPullRequest === true ? `comments on PR #${number}` : `comments on issue #${number}`,
+            };
+        }
+        if (variant.startsWith("PullRequestEvent.closed")) {
+            return {
+                groupable: true,
+                resourceRef: `pr:${number}`,
+                eventFamily: "lifecycle",
+                summaryHint: `PR #${number} lifecycle updates`,
+                flushClass: "immediate",
+            };
+        }
+        return null;
+    },
+    summarizeDigestThread(items, _source, grouping) {
+        if (!grouping.summaryHint || items.length === 0) {
+            return null;
+        }
+        const count = items.length;
+        return `${count} ${grouping.summaryHint}`;
+    },
     projectLifecycleSignal(rawPayload) {
         return (0, github_1.projectGithubLifecycleSignal)(rawPayload);
     },
@@ -298,6 +356,27 @@ const GITHUB_REPO_CI_MODULE = {
         }
         return parts.join(" ");
     },
+    deriveNotificationGrouping(item) {
+        const workflowRunId = typeof item.metadata.workflowRunId === "number" ? item.metadata.workflowRunId : null;
+        if (!workflowRunId) {
+            return null;
+        }
+        const conclusion = asNonEmptyString(item.metadata.conclusion);
+        const status = asNonEmptyString(item.metadata.status);
+        return {
+            groupable: true,
+            resourceRef: `workflow_run:${workflowRunId}`,
+            eventFamily: "ci_updates",
+            summaryHint: `CI updates for run #${workflowRunId}`,
+            flushClass: conclusion || status === "completed" ? "immediate" : "normal",
+        };
+    },
+    summarizeDigestThread(items, _source, grouping) {
+        if (!grouping.summaryHint || items.length === 0) {
+            return null;
+        }
+        return `${items.length} ${grouping.summaryHint}`;
+    },
     validateConfig(source) {
         (0, github_ci_1.parseGithubCiSourceConfig)(source);
     },
@@ -351,6 +430,12 @@ const GITHUB_REPO_CI_MODULE = {
 };
 const FEISHU_BOT_MODULE = {
     id: "builtin.feishu_bot",
+    listDeliveryOperations(input) {
+        return (0, feishu_1.feishuDeliveryOperationsForHandle)(input.handle);
+    },
+    async invokeDeliveryOperation(input) {
+        return (0, feishu_1.invokeFeishuDeliveryOperation)(input.handle, input.operation, input.input);
+    },
     describeCapabilities() {
         return {
             sourceKind: "feishu_bot",
@@ -412,7 +497,7 @@ const FEISHU_BOT_MODULE = {
 function moduleConfigForSource(source) {
     const config = asRecord(source.config);
     if (source.sourceType === "remote_source") {
-        return asRecord(config.profileConfig);
+        return asRecord(config.moduleConfig);
     }
     return config;
 }