@helyx/bot 1.1.0 → 1.2.1

package/CHANGELOG.md

@@ -1,5 +1,76 @@
 # Changelog
 
+## 1.2.1
+
+### Patch Changes
+
+- Load the embedded Auto Moderation engine only for a self-hosted runtime with its
+  scanner provider installed. Core-only and public-module installations no longer
+  require the optional Testing module to import or start the bot. Refresh the
+  self-host catalogue to reference the corrected bot release.
+
+## 1.2.0
+
+### Minor Changes
+
+- 00d33b3: Add the Testing Moderation and Auto Moderation modules, including accountable
+  staff cases, private violation threads, Discord-native rule ownership, bounded
+  rule imports, deterministic repeat-offender actions and shared Hosted and
+  Self-Hosted Enhanced matching. Add the private Helyx Ecko transport, operational
+  gate, aggregate health reporting, content-free scanner telemetry and portable
+  Self-Hosted composition while preserving Standard native enforcement as the
+  failure fallback.
+
+### Patch Changes
+
+- Updated dependencies [00d33b3]
+  - @helyx/config@1.2.0
+  - @helyx/control-protocol@0.5.0
+  - @helyx/database@2.2.0
+  - @helyx/module-manifest@0.10.0
+  - @helyx/platform@1.1.0
+  - @helyx/sdk@0.12.0
+  - @helyx/status-client@0.2.0
+  - @helyx/module-automod@1.0.1
+  - @helyx/module-moderation@1.0.1
+
+## Unreleased
+
+### Minor Changes
+
+- Add deployment-neutral Moderation and Auto Moderation adapters, closed
+  provider registries, feature-scoped message event handling, and bounded
+  dashboard preview/import feature gates for the Phase 6 module boundary.
+- Replace the unused action-v1 and public staff-thread drafts with policy-owned
+  action v2, bounded demotion, role-gated private violation threads and a
+  memory-only single-delivery evidence path.
+- Keep enhanced scanning local to the embedded adapter for self-hosted
+  deployments and explicitly bind hosted scanner calls to the Ecko adapter.
+
+## 1.1.2
+
+### Patch Changes
+
+- 707b68c: Keep hosted server owner observation, manual refresh, and admin leave delivery available independently of the hosted moderation incident gate.
+- Preserve successful support-notification acknowledgements across child-process IPC so delivered Discord notifications are not retried and falsely marked as failed.
+
+## 1.1.1
+
+### Patch Changes
+
+- Bound Discord thread inspection to the scheduled-task deadline, reuse recent
+  active-thread snapshots, allow existing Analytics filter exclusions to be
+  replaced atomically, and remove duplicate dashboard columns that contributed to
+  mobile overflow.
+- Expose the hosted-moderation runtime flag through the authenticated bot control
+  boundary so Admin incident-gate availability cannot report a disabled runtime
+  as enabled.
+- Deliver Admin leave and blacklist requests immediately through the owning bot
+  shard while retaining their durable retry queue, and persist cached Discord
+  owner usernames atomically with hosted server reconciliation. Add an audited
+  Admin fallback that refreshes a missing owner username through the owning bot
+  shard and saves the observation.
+
 ## 1.1.0
 
 ### Minor Changes

package/README.md

@@ -34,7 +34,22 @@ upgrades preserve each server's existing enabled or disabled state.
 
 Gateway intents are derived from installed event contributions. The bot always requests Guilds, adds non-privileged reaction access only for reaction modules, and adds the privileged Server Members intent only when an installed module handles member joins. Deployments containing such a module must enable the matching intent in the Discord Developer Portal before startup.
 
-When `HELYX_BOT_CONTROL_SECRET` is configured, the bot also starts a private authenticated HTTP control server on `HELYX_BOT_CONTROL_PORT`. The dashboard API uses this service to obtain real Discord roles and channels and to apply validated module, configuration and permission changes. Only `/health` is unauthenticated; all `/v1` routes require the shared bearer secret. Keep this endpoint on a private service network and do not assign it a public domain.
+Moderation integrations use closed, versioned service contracts for native
+Discord Auto Moderation rules, member and message enforcement, restricted
+private violation threads, transient evidence and module-owned action/policy
+providers. Auto Moderation supplies the live rule policy and Moderation owns the
+effect; the caller cannot choose an offence step or action. Feature-scoped
+privileged message listeners are excluded from the hosted main bot; self-hosted
+runtimes may compose the same scanning contract through the explicitly selected
+embedded adapter when the module feature is available. Hosted Ecko transport and
+embedded callers are identity-bound and cannot be interchanged.
+
+Dashboard settings previews and managed-resource imports are bounded,
+non-persisting module operations. Core validates their declared inputs and
+fresh feature access before execution, then validates and projects structured
+results before they cross the control boundary.
+
+When `HELYX_BOT_CONTROL_SECRET` is configured, the bot also starts a private authenticated HTTP control server on `HELYX_BOT_CONTROL_PORT`. The dashboard API uses this service to obtain real Discord roles and channels and to apply validated module, configuration and permission changes. `/health` is unauthenticated. Ordinary `/v1` routes require the shared bearer secret; the narrow `/v1/ecko/*` routes instead require their dedicated rotating HMAC transport key. Keep this endpoint on a private service network and do not assign it a public domain.
 
 Optional Helyx Cloud Connect is a separate outbound management path for self-hosted deployments. It is disabled unless `HELYX_CLOUD_CONNECT_ENABLED=true` and requires a separate local `HELYX_DATA_ENCRYPTION_KEY`. Preserve that key across every restart and deployment. If it is lost or changed, revoke the old installation in the dashboard and use a new one-use code with `/helyx-cloud connect`; the connector stops retrying until that recovery is completed. The owner-only `/helyx-cloud` command supports connection-code enrolment, status, credential rotation, disconnection and bounded support consent. The bot never sends its Discord token, database URL or connector private key to Helyx Cloud, and local Discord operation continues when Cloud is unavailable.
 

package/dist/auto-moderation-scanner-registry.d.ts

@@ -0,0 +1,27 @@
+import type { AutoModerationEnhancedResultOutcome, AutoModerationScannerAdapterSelection, AutoModerationScannerConfigurationPageV1, AutoModerationScannerProviderRegistryService, ModuleDefinition, ServiceAccess } from "@helyx/sdk";
+import { AUTOMOD_ENHANCED_CONTRACT_VERSION, AUTOMOD_ENHANCED_PROVIDER_ID } from "@helyx/sdk";
+import type { TransientViolationEvidenceStore } from "./transient-violation-evidence.js";
+/** Closed scanner registry local to an unsharded bot or one guild-owning worker. */
+export declare class BotAutoModerationScannerRegistry implements AutoModerationScannerProviderRegistryService {
+    #private;
+    private readonly services;
+    private readonly runtimeProfile;
+    private readonly evidenceStore?;
+    private readonly deploymentEnvironment;
+    constructor(modules: readonly ModuleDefinition[], services: ServiceAccess, runtimeProfile: "hosted" | "self-hosted", evidenceStore?: TransientViolationEvidenceStore | undefined, deploymentEnvironment?: string);
+    select(input: {
+        guildId: string;
+        moduleId: string;
+        featureId: string;
+    }): Promise<AutoModerationScannerAdapterSelection>;
+    getConfigurationPage(input: {
+        adapter: "hosted_ecko" | "embedded";
+        providerId: typeof AUTOMOD_ENHANCED_PROVIDER_ID;
+        contractVersion: typeof AUTOMOD_ENHANCED_CONTRACT_VERSION;
+        cursor?: string;
+        limit: number;
+        knownFingerprint?: string;
+    }): Promise<AutoModerationScannerConfigurationPageV1>;
+    acceptResult(input: Parameters<AutoModerationScannerProviderRegistryService["acceptResult"]>[0]): Promise<AutoModerationEnhancedResultOutcome>;
+}
+//# sourceMappingURL=auto-moderation-scanner-registry.d.ts.map

package/dist/auto-moderation-scanner-registry.js

@@ -0,0 +1,172 @@
+import { HELYX_AUTOMOD_ENHANCED_SCANNING_FEATURE } from "@helyx/module-manifest";
+import { AUTOMOD_ENHANCED_CONFIG_PROTOCOL, AUTOMOD_ENHANCED_CONTRACT_VERSION, AUTOMOD_ENHANCED_EVIDENCE_PROTOCOL, AUTOMOD_ENHANCED_PROVIDER_ID, AUTOMOD_ENHANCED_RESULT_PROTOCOL, AUTOMOD_SCANNER_LIMITS, HELYX_SERVICE_NAMES, } from "@helyx/sdk";
+const AUTOMOD_MODULE_ID = "helyx.automod";
+/** Closed scanner registry local to an unsharded bot or one guild-owning worker. */
+export class BotAutoModerationScannerRegistry {
+    services;
+    runtimeProfile;
+    evidenceStore;
+    deploymentEnvironment;
+    #provider;
+    constructor(modules, services, runtimeProfile, evidenceStore, deploymentEnvironment = runtimeProfile === "hosted"
+        ? "production"
+        : "self-hosted") {
+        this.services = services;
+        this.runtimeProfile = runtimeProfile;
+        this.evidenceStore = evidenceStore;
+        this.deploymentEnvironment = deploymentEnvironment;
+        const providers = modules.flatMap((module) => module.autoModerationScannerProvider
+            ? [
+                {
+                    moduleId: module.manifest.id,
+                    provider: module.autoModerationScannerProvider,
+                },
+            ]
+            : []);
+        if (providers.length > 1)
+            throw new Error("Auto Moderation scanner provider ownership is ambiguous");
+        const registered = providers[0];
+        if (!registered) {
+            this.#provider = null;
+            return;
+        }
+        if (registered.moduleId !== AUTOMOD_MODULE_ID ||
+            registered.provider.providerId !== AUTOMOD_ENHANCED_PROVIDER_ID ||
+            registered.provider.contractVersion !==
+                AUTOMOD_ENHANCED_CONTRACT_VERSION ||
+            registered.provider.configurationProtocol !==
+                AUTOMOD_ENHANCED_CONFIG_PROTOCOL ||
+            registered.provider.resultProtocol !== AUTOMOD_ENHANCED_RESULT_PROTOCOL ||
+            registered.provider.evidenceProtocol !==
+                AUTOMOD_ENHANCED_EVIDENCE_PROTOCOL)
+            throw new Error("Auto Moderation scanner provider registration is invalid");
+        this.#provider = registered.provider;
+    }
+    async select(input) {
+        if (!this.#provider ||
+            input.moduleId !== AUTOMOD_MODULE_ID ||
+            input.featureId !== HELYX_AUTOMOD_ENHANCED_SCANNING_FEATURE)
+            return unavailable("dependency_unhealthy");
+        try {
+            if (!(await this.#moduleEnabled(input.guildId)))
+                return unavailable("dependency_unhealthy");
+            const access = await this.services
+                .get(HELYX_SERVICE_NAMES.featureAccess)
+                .check(input);
+            if (access.decision !== "granted")
+                return unavailable(access.decision === "not_entitled"
+                    ? "feature_unavailable"
+                    : access.decision);
+            return this.runtimeProfile === "hosted"
+                ? { adapter: "hosted_ecko", available: true }
+                : { adapter: "embedded", available: true };
+        }
+        catch {
+            return unavailable("dependency_unhealthy");
+        }
+    }
+    async getConfigurationPage(input) {
+        if (!this.#provider ||
+            input.adapter !== expectedAdapter(this.runtimeProfile) ||
+            input.providerId !== AUTOMOD_ENHANCED_PROVIDER_ID ||
+            input.contractVersion !== AUTOMOD_ENHANCED_CONTRACT_VERSION ||
+            !Number.isInteger(input.limit) ||
+            input.limit < 1 ||
+            input.limit > AUTOMOD_SCANNER_LIMITS.configurationPageServers)
+            throw new Error("Auto Moderation scanner configuration request is invalid");
+        const page = await this.#provider.getConfigurationPage({ services: this.services }, {
+            limit: input.limit,
+            ...(input.cursor ? { cursor: input.cursor } : {}),
+            ...(input.knownFingerprint
+                ? { knownFingerprint: input.knownFingerprint }
+                : {}),
+        });
+        validateConfigurationPage(page);
+        return page;
+    }
+    async acceptResult(input) {
+        try {
+            if (input.adapter !== expectedAdapter(this.runtimeProfile))
+                return rejected("wrong_owner");
+            if (!this.#provider ||
+                input.providerId !== AUTOMOD_ENHANCED_PROVIDER_ID ||
+                input.contractVersion !== AUTOMOD_ENHANCED_CONTRACT_VERSION)
+                return rejected("unknown_version");
+            let result;
+            try {
+                result = this.#provider.validateResult(input.result);
+            }
+            catch {
+                return rejected("invalid_envelope");
+            }
+            if (result.protocol !== AUTOMOD_ENHANCED_RESULT_PROTOCOL ||
+                result.providerId !== AUTOMOD_ENHANCED_PROVIDER_ID ||
+                result.contractVersion !== AUTOMOD_ENHANCED_CONTRACT_VERSION)
+                return rejected("unknown_version");
+            if (result.environment !== this.deploymentEnvironment)
+                return rejected("wrong_owner");
+            const evidenceReference = input.evidenceReference ?? null;
+            if (evidenceReference &&
+                (evidenceReference.source !== "enhanced_scanner" ||
+                    evidenceReference.sourceEventId !== result.operationId ||
+                    evidenceReference.configurationRevision !==
+                        result.configurationRevision ||
+                    evidenceReference.guildId !== result.guildId ||
+                    evidenceReference.channelId !== result.channelId ||
+                    evidenceReference.messageId !== result.messageId ||
+                    evidenceReference.authorUserId !== result.authorUserId))
+                return rejected("invalid_envelope");
+            if (!(await this.#moduleEnabled(result.guildId)))
+                return rejected("module_unavailable");
+            const access = await this.services
+                .get(HELYX_SERVICE_NAMES.featureAccess)
+                .check({
+                guildId: result.guildId,
+                moduleId: AUTOMOD_MODULE_ID,
+                featureId: HELYX_AUTOMOD_ENHANCED_SCANNING_FEATURE,
+            })
+                .catch(() => ({ decision: "dependency_unhealthy" }));
+            if (access.decision !== "granted")
+                return rejected("feature_unavailable");
+            try {
+                return await this.#provider.handleResult({ services: this.services, evidenceReference }, result);
+            }
+            catch {
+                return rejected("module_unavailable");
+            }
+        }
+        finally {
+            if (input.evidenceReference)
+                this.evidenceStore?.discard(input.evidenceReference);
+        }
+    }
+    async #moduleEnabled(guildId) {
+        const installation = this.services.get(HELYX_SERVICE_NAMES.installations);
+        if (!(await installation.isModuleEnabled(guildId, AUTOMOD_MODULE_ID)))
+            return false;
+        if (!this.services.has(HELYX_SERVICE_NAMES.moduleAvailability))
+            return true;
+        return this.services
+            .get(HELYX_SERVICE_NAMES.moduleAvailability)
+            .isAvailable(AUTOMOD_MODULE_ID);
+    }
+}
+function expectedAdapter(runtimeProfile) {
+    return runtimeProfile === "hosted" ? "hosted_ecko" : "embedded";
+}
+function validateConfigurationPage(page) {
+    if (page.protocol !== AUTOMOD_ENHANCED_CONFIG_PROTOCOL ||
+        page.providerId !== AUTOMOD_ENHANCED_PROVIDER_ID ||
+        page.contractVersion !== AUTOMOD_ENHANCED_CONTRACT_VERSION ||
+        page.items.length > AUTOMOD_SCANNER_LIMITS.configurationPageServers ||
+        Buffer.byteLength(JSON.stringify(page), "utf8") >
+            AUTOMOD_SCANNER_LIMITS.configurationPageBytes)
+        throw new Error("Auto Moderation scanner configuration page is invalid");
+}
+function unavailable(reason) {
+    return { adapter: "unavailable", available: false, reason };
+}
+function rejected(code) {
+    return { outcome: "rejected", code };
+}
+//# sourceMappingURL=auto-moderation-scanner-registry.js.map

package/dist/cloud-connector.js

@@ -725,13 +725,16 @@ function connectorCapabilities() {
         "guild.module.public.read.v1",
         "guild.module.status.write.v1",
         "guild.module.configuration.write.v1",
+        "guild.module.configuration.preview.v1",
         "guild.module.permissions.write.v1",
         "guild.module.logging.write.v1",
         "guild.module.action.execute.v1",
+        "guild.module.action.preview.v1",
         "guild.module.resource.list.v1",
         "guild.module.resource.read.v1",
         "guild.module.resource.relation.list.v1",
         "guild.module.resource.preview.v1",
+        "guild.module.resource.import.v1",
         "guild.module.resource.create.v1",
         "guild.module.resource.update.v1",
         "guild.module.resource.delete.v1",

package/dist/cloud-control-dispatcher.js

@@ -83,6 +83,15 @@ export class CloudControlDispatcher {
                 });
                 break;
             }
+            case "guild.module.configuration.preview.v1": {
+                const input = parseOperationInput(request.operation, request.input);
+                result = await this.control.previewConfiguration({
+                    ...input,
+                    actorUserId: requiredActor(actorUserId),
+                    correlationId,
+                });
+                break;
+            }
             case "guild.module.permissions.write.v1": {
                 const input = parseOperationInput(request.operation, request.input);
                 result = await this.control.updatePermissions({
@@ -104,6 +113,20 @@ export class CloudControlDispatcher {
             case "guild.module.action.execute.v1": {
                 const input = parseOperationInput(request.operation, request.input);
                 result = await this.control.executeDashboardAction({
+                    guildId: input.guildId,
+                    moduleId: input.moduleId,
+                    actionId: input.actionId,
+                    ...(input.inspectionRevision === undefined
+                        ? {}
+                        : { inspectionRevision: input.inspectionRevision }),
+                    actorUserId: requiredActor(actorUserId),
+                    correlationId,
+                });
+                break;
+            }
+            case "guild.module.action.preview.v1": {
+                const input = parseOperationInput(request.operation, request.input);
+                result = await this.control.previewDashboardAction({
                     ...input,
                     actorUserId: requiredActor(actorUserId),
                     correlationId,
@@ -160,6 +183,15 @@ export class CloudControlDispatcher {
                 });
                 break;
             }
+            case "guild.module.resource.import.v1": {
+                const input = parseOperationInput(request.operation, request.input);
+                result = await this.control.importManagedResource({
+                    ...input,
+                    actorUserId: requiredActor(actorUserId),
+                    correlationId,
+                });
+                break;
+            }
             case "guild.module.resource.create.v1": {
                 const input = parseOperationInput(request.operation, request.input);
                 result = await this.control.createManagedResource({

package/dist/command-path-contract.js

@@ -32,6 +32,7 @@ export function collectCommandPermissionTargets(module) {
             description: command.description,
             kind: "command",
         })),
+        ...permissionOperations(module.permissionOperations),
         ...(module.interactions?.commands ?? []).flatMap((command) => [
             ...permissionOperations(command.permissionOperations),
             ...(command.subcommands ?? []).flatMap((subcommand) => permissionOperations(subcommand.permissionOperations)),

package/dist/control-permissions.d.ts

@@ -23,9 +23,9 @@ export interface ResolvedPermissionPolicy extends PermissionPolicyTarget {
     version: bigint | null;
     inherited: boolean;
 }
-export type ManagedResourceOperation = "list" | "read" | "preview" | "create" | "update" | "delete" | "action";
+export type ManagedResourceOperation = "list" | "read" | "preview" | "create" | "update" | "delete" | "action" | "import";
 export declare function declaredManagedResourcePermission(module: ModuleDefinition, resourceType: string, operation: ManagedResourceOperation): string | undefined;
-export declare function dashboardActionPermissionId(module: ModuleDefinition, actionId: string): string;
+export declare function dashboardActionPermissionId(module: ModuleDefinition, actionId: string, declaredPermissionId?: string): string;
 export declare function managedResourcePermissionId(module: ModuleDefinition, resourceType: string, operation: ManagedResourceOperation, actionId?: string, declaredPermissionId?: string): string;
 export declare function permissionPolicyKey(target: PermissionPolicyTarget): string;
 export declare function toDashboardPolicy(policy: PermissionPolicy): DashboardPermissionPolicy;

package/dist/control-permissions.js

@@ -4,7 +4,9 @@ export function declaredManagedResourcePermission(module, resourceType, operatio
         return undefined;
     return module.manifest.dashboard?.resources?.find(({ id }) => id === resourceType)?.permissions?.[operation];
 }
-export function dashboardActionPermissionId(module, actionId) {
+export function dashboardActionPermissionId(module, actionId, declaredPermissionId) {
+    if (declaredPermissionId)
+        return declaredPermissionId;
     const namespace = modulePermissionNamespace(module);
     return selectDeclaredPermission(module, [
         `${namespace}.${actionId.replaceAll("-", ".")}`,
@@ -17,7 +19,7 @@ export function managedResourcePermissionId(module, resourceType, operation, act
         return declaredPermissionId;
     const namespace = modulePermissionNamespace(module);
     const resourcePermission = `resource.${resourceType}`;
-    const candidates = operation === "create" || operation === "preview"
+    const candidates = operation === "create" || operation === "preview" || operation === "import"
         ? [
             `${resourcePermission}.create`,
             `${namespace}.create`,

package/dist/control-server.d.ts

@@ -1,5 +1,5 @@
 import { type DatabasePool, type GuildShardOwnership } from "@helyx/database";
-import { type DashboardActionResult, type GuildAccessPolicy, type ManagedResourceCreationIntent, type ManagedResourceDetail, type ManagedResourcePage, type ManagedResourceRelationPage, type ManagedResourceValue, type MessageResponse, type ModuleDefinition, type OAuthConsumerCleanupResult, type PermissionActor, type PrivacyCapturePage, type PrivacyErasePage, type PrivacyProviderExecutor, type PublicAchievementProjectionPage, type ServiceAccess } from "@helyx/sdk";
+import { type DashboardActionInspection, type DashboardActionResult, type FeatureAccessDecision, type GuildAccessPolicy, type ManagedResourceCreationIntent, type ManagedResourceDetail, type ManagedResourcePage, type ManagedResourceRelationPage, type ManagedResourceValue, type MessageResponse, type ModuleDefinition, type OAuthConsumerCleanupResult, type PermissionActor, type PrivacyCapturePage, type PrivacyErasePage, type PrivacyProviderExecutor, type PublicAchievementProjectionPage, type ServiceAccess } from "@helyx/sdk";
 import { type ActionReceipt, type SignedAssessmentEnvelope } from "@helyx/verification-contracts";
 import { type Client } from "discord.js";
 import { type FastifyInstance } from "fastify";
@@ -10,6 +10,12 @@ import { type DashboardPermissionState } from "./control-permissions.js";
 import { type DashboardModuleDefinition } from "./dashboard-module-projection.js";
 import { type AvailabilityModuleCatalogue } from "./module-availability-control.js";
 import { registerGuildCommandControlRoutes } from "./guild-command-control-routes.js";
+import { type DashboardActionInput, type DashboardActionPreviewInput } from "./dashboard-action-control.js";
+import { type DashboardActionHandler } from "./dashboard-action-routes.js";
+import { type EckoTelemetrySink } from "./ecko-transport-routes.js";
+import type { EckoEvidenceReceiver } from "./ecko-evidence-receiver.js";
+import type { EckoTransportAuthenticator } from "./ecko-transport-auth.js";
+import type { AutoModerationScannerProviderRegistryService } from "@helyx/sdk";
 interface DashboardLoggingPolicy {
     eventId: string;
     enabled: boolean;
@@ -93,6 +99,7 @@ export interface BotControlState {
     channels: BotControlGuildResources["channels"];
     roles: BotControlGuildResources["roles"];
     modules: DashboardModuleDefinition[];
+    featureAccess?: Record<string, Record<string, FeatureAccessDecision>>;
     moduleStatuses: Record<string, "enabled" | "disabled" | "unavailable">;
     globallyDisabledModuleIds: string[];
     configurations: Record<string, {
@@ -110,7 +117,7 @@ export interface DashboardGuildAccessState extends GuildAccessPolicy {
     actorHighestRolePosition: number | null;
     updatedAt: string | null;
 }
-export interface BotControlHandler extends FirstTimeCommandSetupHandler {
+export interface BotControlHandler extends FirstTimeCommandSetupHandler, DashboardActionHandler {
     cleanupOAuthConsumer(input: {
         consumerBindingId: string;
         moduleId: string;
@@ -176,6 +183,14 @@ export interface BotControlHandler extends FirstTimeCommandSetupHandler {
         value: Record<string, unknown>;
         version: number;
     }>;
+    previewConfiguration(input: {
+        guildId: string;
+        moduleId: string;
+        value: Record<string, unknown>;
+        input: Readonly<Record<string, ManagedResourceValue>>;
+        actorUserId: string;
+        correlationId: string;
+    }): Promise<MessageResponse>;
     updatePermissions(input: {
         guildId: string;
         moduleId: string;
@@ -192,13 +207,6 @@ export interface BotControlHandler extends FirstTimeCommandSetupHandler {
         actorUserId: string;
         correlationId: string;
     }): Promise<DashboardLoggingPolicy>;
-    executeDashboardAction(input: {
-        guildId: string;
-        moduleId: string;
-        actionId: string;
-        actorUserId: string;
-        correlationId: string;
-    }): Promise<DashboardActionResult>;
     listManagedResources(input: {
         guildId: string;
         moduleId: string;
@@ -239,6 +247,18 @@ export interface BotControlHandler extends FirstTimeCommandSetupHandler {
         actorUserId: string;
         correlationId: string;
     }): Promise<MessageResponse>;
+    importManagedResource(input: {
+        guildId: string;
+        moduleId: string;
+        resourceType: string;
+        format: "utf8_text";
+        content: string;
+        actorUserId: string;
+        correlationId: string;
+    }): Promise<{
+        value: Readonly<Record<string, ManagedResourceValue>>;
+        preview: Readonly<Record<string, ManagedResourceValue>>;
+    }>;
     createManagedResource(input: {
         guildId: string;
         moduleId: string;
@@ -413,6 +433,14 @@ export declare class BotControlService implements BotControlHandler {
         value: Record<string, unknown>;
         version: number;
     }>;
+    previewConfiguration(input: {
+        guildId: string;
+        moduleId: string;
+        value: Record<string, unknown>;
+        input: Readonly<Record<string, ManagedResourceValue>>;
+        actorUserId: string;
+        correlationId: string;
+    }): Promise<Readonly<Record<string, ManagedResourceValue>>>;
     updatePermissions(input: {
         guildId: string;
         moduleId: string;
@@ -429,13 +457,8 @@ export declare class BotControlService implements BotControlHandler {
         actorUserId: string;
         correlationId: string;
     }): Promise<DashboardLoggingPolicy>;
-    executeDashboardAction(input: {
-        guildId: string;
-        moduleId: string;
-        actionId: string;
-        actorUserId: string;
-        correlationId: string;
-    }): Promise<DashboardActionResult>;
+    executeDashboardAction(input: DashboardActionInput): Promise<DashboardActionResult>;
+    previewDashboardAction(input: DashboardActionPreviewInput): Promise<DashboardActionInspection>;
     listManagedResources(input: {
         guildId: string;
         moduleId: string;
@@ -476,6 +499,18 @@ export declare class BotControlService implements BotControlHandler {
         actorUserId: string;
         correlationId: string;
     }): Promise<MessageResponse>;
+    importManagedResource(input: {
+        guildId: string;
+        moduleId: string;
+        resourceType: string;
+        format: "utf8_text";
+        content: string;
+        actorUserId: string;
+        correlationId: string;
+    }): Promise<{
+        value: Readonly<Record<string, ManagedResourceValue>>;
+        preview: Readonly<Record<string, ManagedResourceValue>>;
+    }>;
     createManagedResource(input: {
         guildId: string;
         moduleId: string;
@@ -526,9 +561,30 @@ export declare function createBotControlServer(input: {
     logger?: boolean | {
         level: string;
     };
+    runtimeConfiguration?: {
+        hostedModerationEnabled: boolean;
+    };
     shardHealth?: () => Promise<ShardHealthSnapshot>;
     readiness?: () => Promise<boolean>;
+    deliverHostedServerLeave?: (input: {
+        operationId: string;
+        guildId: string;
+    }) => Promise<"queued" | "completed" | "not_currently_installed" | "accepted_for_retry" | "requires_review">;
+    refreshHostedServerOwner?: (guildId: string) => Promise<{
+        username: string;
+        observedAt: string;
+    }>;
     guildCommands?: Parameters<typeof registerGuildCommandControlRoutes>[1];
+    ecko?: {
+        authenticator: EckoTransportAuthenticator;
+        registry: AutoModerationScannerProviderRegistryService;
+        evidence: EckoEvidenceReceiver;
+        gateState(): Promise<{
+            state: "enabled" | "draining" | "disabled";
+            updatedAt: Date;
+        }>;
+        telemetry?: EckoTelemetrySink;
+    };
 }): Promise<FastifyInstance>;
 export declare function mapBotControlError(error: unknown): {
     status: 400 | 403 | 404 | 409;