@holon-run/agentinbox 0.6.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

@@ -4,7 +4,7 @@ exports.resolveSourceIdentity = resolveSourceIdentity;
 exports.resolveSourceSchema = resolveSourceSchema;
 exports.withResolvedIdentity = withResolvedIdentity;
 const paths_1 = require("./paths");
-const remote_profiles_1 = require("./sources/remote_profiles");
+const remote_modules_1 = require("./sources/remote_modules");
 const source_schema_1 = require("./source_schema");
 async function resolveSourceIdentity(source, context = {}) {
     if (source.sourceType === "local_event") {
@@ -14,7 +14,7 @@ async function resolveSourceIdentity(source, context = {}) {
             implementationId: "builtin.local_event",
         };
     }
-    const builtinImplementationId = (0, remote_profiles_1.builtInProfileIdForSourceType)(source.sourceType);
+    const builtinImplementationId = (0, remote_modules_1.builtInModuleIdForSourceType)(source.sourceType);
     if (builtinImplementationId) {
         return {
             hostType: "remote_source",
@@ -25,30 +25,30 @@ async function resolveSourceIdentity(source, context = {}) {
     if (source.sourceType !== "remote_source") {
         throw new Error(`unsupported source type for source resolution: ${source.sourceType}`);
     }
-    const profileRegistry = context.profileRegistry ?? new remote_profiles_1.RemoteSourceProfileRegistry();
+    const moduleRegistry = context.moduleRegistry ?? new remote_modules_1.RemoteSourceModuleRegistry();
     const homeDir = context.homeDir ?? (0, paths_1.resolveAgentInboxHome)(process.env);
-    const profile = await profileRegistry.resolve(source, homeDir);
-    const capabilityDescription = typeof profile.describeCapabilities === "function"
-        ? profile.describeCapabilities(profileInputSource(source))
+    const module = await moduleRegistry.resolve(source, homeDir);
+    const capabilityDescription = typeof module.describeCapabilities === "function"
+        ? module.describeCapabilities(moduleInputSource(source))
         : undefined;
     return {
         hostType: "remote_source",
-        sourceKind: capabilityDescription?.sourceKind?.trim() || `remote:${profile.id}`,
-        implementationId: profile.id,
+        sourceKind: capabilityDescription?.sourceKind?.trim() || `remote:${module.id}`,
+        implementationId: module.id,
     };
 }
 async function resolveSourceSchema(source, context = {}) {
-    const profileRegistry = context.profileRegistry ?? new remote_profiles_1.RemoteSourceProfileRegistry();
+    const moduleRegistry = context.moduleRegistry ?? new remote_modules_1.RemoteSourceModuleRegistry();
     const homeDir = context.homeDir ?? (0, paths_1.resolveAgentInboxHome)(process.env);
-    const resolvedContext = { ...context, profileRegistry, homeDir };
+    const resolvedContext = { ...context, moduleRegistry, homeDir };
     const identity = await resolveSourceIdentity(source, resolvedContext);
     const staticSchema = (0, source_schema_1.getSourceSchema)(source.sourceType);
     let capabilityDescription;
-    let profile = null;
+    let module = null;
     if (identity.hostType === "remote_source") {
-        profile = await profileRegistry.resolve(source, homeDir);
-        capabilityDescription = typeof profile.describeCapabilities === "function"
-            ? profile.describeCapabilities(profileInputSource(source))
+        module = await moduleRegistry.resolve(source, homeDir);
+        capabilityDescription = typeof module.describeCapabilities === "function"
+            ? module.describeCapabilities(moduleInputSource(source))
             : undefined;
     }
     return withResolvedIdentity(source.sourceId, {
@@ -60,10 +60,10 @@ async function resolveSourceSchema(source, context = {}) {
     }, identity, identity.hostType === "remote_source"
         ? {
             aliases: capabilityDescription?.aliases,
-            supportsTrackedResourceRef: typeof profile?.deriveTrackedResource === "function",
-            supportsLifecycleSignals: typeof profile?.projectLifecycleSignal === "function",
-            shortcuts: typeof profile?.listSubscriptionShortcuts === "function"
-                ? profile.listSubscriptionShortcuts(profileInputSource(source))
+            supportsTrackedResourceRef: typeof module?.deriveTrackedResource === "function",
+            supportsLifecycleSignals: typeof module?.projectLifecycleSignal === "function",
+            shortcuts: typeof module?.listSubscriptionShortcuts === "function"
+                ? module.listSubscriptionShortcuts(moduleInputSource(source))
                 : [],
         }
         : undefined);
@@ -89,12 +89,12 @@ function withResolvedIdentity(sourceId, schema, identity, capabilityMetadata) {
         } : {}),
     };
 }
-function profileInputSource(source) {
+function moduleInputSource(source) {
     if (source.sourceType !== "remote_source") {
         return source;
     }
     return {
         ...source,
-        config: (0, remote_profiles_1.profileConfigForSource)(source),
+        config: (0, remote_modules_1.moduleConfigForSource)(source),
     };
 }

package/dist/src/source_schema.js

@@ -21,8 +21,8 @@ const SOURCE_SCHEMAS = {
         payloadExamples: [],
         eventVariantExamples: [],
         configFields: [
-            { name: "profilePath", type: "string", required: true, description: "Local profile module path under $AGENTINBOX_HOME/source-profiles." },
-            { name: "profileConfig", type: "object", required: false, description: "Profile-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

@@ -4,7 +4,7 @@ exports.RemoteSourceRuntime = exports.RpcUxcRemoteSourceClient = void 0;
 const uxc_daemon_client_1 = require("@holon-run/uxc-daemon-client");
 const paths_1 = require("../paths");
 const util_1 = require("../util");
-const remote_profiles_1 = require("./remote_profiles");
+const remote_modules_1 = require("./remote_modules");
 const REMOTE_SOURCE_TYPES = new Set([
     "remote_source",
     "github_repo",
@@ -55,7 +55,7 @@ exports.RpcUxcRemoteSourceClient = RpcUxcRemoteSourceClient;
 class RemoteSourceRuntime {
     store;
     appendSourceEvent;
-    profileRegistry;
+    moduleRegistry;
     client;
     interval = null;
     inFlight = new Set();
@@ -65,7 +65,7 @@ class RemoteSourceRuntime {
     constructor(store, appendSourceEvent, options) {
         this.store = store;
         this.appendSourceEvent = appendSourceEvent;
-        this.profileRegistry = options?.profileRegistry ?? new remote_profiles_1.RemoteSourceProfileRegistry();
+        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);
     }
@@ -79,10 +79,10 @@ class RemoteSourceRuntime {
         if (!REMOTE_SOURCE_TYPES.has(source.sourceType)) {
             return;
         }
-        const profile = await this.profileRegistry.resolve(source, this.homeDir);
-        const profileSource = profileInputSource(source);
-        profile.validateConfig(profileSource);
-        profile.buildManagedSourceSpec(profileSource);
+        const module = await this.moduleRegistry.resolve(source, this.homeDir);
+        const moduleSource = moduleInputSource(source);
+        module.validateConfig(moduleSource);
+        module.buildManagedSourceSpec(moduleSource);
     }
     async start() {
         if (this.interval) {
@@ -171,35 +171,55 @@ class RemoteSourceRuntime {
         if (!REMOTE_SOURCE_TYPES.has(source.sourceType)) {
             return null;
         }
-        const profile = await this.profileRegistry.resolve(source, this.homeDir);
-        if (typeof profile.projectLifecycleSignal !== "function") {
+        const module = await this.moduleRegistry.resolve(source, this.homeDir);
+        if (typeof module.projectLifecycleSignal !== "function") {
             return null;
         }
-        return profile.projectLifecycleSignal(rawPayload, profileInputSource(source));
+        return module.projectLifecycleSignal(rawPayload, moduleInputSource(source));
     }
     async expandSubscriptionShortcut(source, input) {
         if (!REMOTE_SOURCE_TYPES.has(source.sourceType)) {
             return null;
         }
-        const profile = await this.profileRegistry.resolve(source, this.homeDir);
-        if (typeof profile.expandSubscriptionShortcut !== "function") {
+        const module = await this.moduleRegistry.resolve(source, this.homeDir);
+        if (typeof module.expandSubscriptionShortcut !== "function") {
             return null;
         }
-        return profile.expandSubscriptionShortcut({
+        return module.expandSubscriptionShortcut({
             name: input.name,
             args: input.args,
-            source: profileInputSource(source),
+            source: moduleInputSource(source),
         });
     }
     async deriveInlinePreview(source, item) {
         if (!REMOTE_SOURCE_TYPES.has(source.sourceType)) {
             return null;
         }
-        const profile = await this.profileRegistry.resolve(source, this.homeDir);
-        if (typeof profile.deriveInlinePreview !== "function") {
+        const module = await this.moduleRegistry.resolve(source, this.homeDir);
+        if (typeof module.deriveInlinePreview !== "function") {
             return null;
         }
-        return profile.deriveInlinePreview(item, profileInputSource(source));
+        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
@@ -255,10 +275,10 @@ class RemoteSourceRuntime {
                     };
                 }
             }
-            const profile = await this.profileRegistry.resolve(source, this.homeDir);
-            const profileSource = profileInputSource(source);
-            profile.validateConfig(profileSource);
-            const spec = profile.buildManagedSourceSpec(profileSource);
+            const module = await this.moduleRegistry.resolve(source, this.homeDir);
+            const moduleSource = moduleInputSource(source);
+            module.validateConfig(moduleSource);
+            const spec = module.buildManagedSourceSpec(moduleSource);
             const binding = managedBindingForSource(source);
             const ensured = await this.client.sourceEnsure({
                 namespace: binding.namespace,
@@ -279,7 +299,7 @@ class RemoteSourceRuntime {
                 if (Object.keys(rawPayload).length === 0) {
                     continue;
                 }
-                const mapped = profile.mapRawEvent(rawPayload, profileSource);
+                const mapped = module.mapRawEvent(rawPayload, moduleSource);
                 if (!mapped) {
                     continue;
                 }
@@ -348,14 +368,14 @@ class RemoteSourceRuntime {
     }
 }
 exports.RemoteSourceRuntime = RemoteSourceRuntime;
-function profileInputSource(source) {
+function moduleInputSource(source) {
     if (source.sourceType !== "remote_source") {
         return source;
     }
     const config = asRecord(source.config);
     return {
         ...source,
-        config: asRecord(config.profileConfig),
+        config: asRecord(config.moduleConfig),
     };
 }
 function defaultManagedBindingForSource(source) {