diff --git a/docs/engine-overview.md b/docs/engine-overview.md
new file mode 100644
index 00000000..b55fafac
--- /dev/null
+++ b/docs/engine-overview.md
@@ -0,0 +1,23 @@
+# Engine contracts overview
+
+This repository now exposes transport-agnostic engines that sit inside each module. Engines describe their contracts in a manifest and can be surfaced through adapters when a host wants to expose UI or webhook behaviors.
+
+## Core building blocks
+
+- **Engine manifest** (`ModuleEngineManifest`)
+  - Identifies the engine (`Id`, `Version`, `Description`, `Kind`, optional `FeatureArea`).
+  - Declares capabilities, schemas, security, compatibility expectations, and navigation hints via strongly typed records/enums (`ModuleEngineNavigationHints`, `ModuleNavigationToken`, `NavigationTargetKind`, `ModuleSignatureAlgorithm`).
+  - Declares `RequiredServices` – a list of logical capabilities (for example `IApiClient`, `ICache`, `ITelemetry`) that must be provided by the host for the engine to run. Hosts are expected to validate that every required service can be satisfied before executing an engine, typically by mapping each required service identifier to a concrete implementation in their DI container or adapter configuration. Adapters enforce this validation by consulting `IRequiredServiceValidator`; hosts should register a validator or surface a configuration error when validation fails.
+  - Adds optional webhook metadata (`ModuleEngineWebhookMetadata`) for providers and event types.
+- **Engine descriptor** (`ModuleEngineDescriptor<TContract>`) wraps the manifest with a strongly typed factory so hosts can resolve engines without `object` casts.
+- **Discovery** (`ModuleEngineDiscoveryService`/`ModuleEngineRegistry`) stores descriptors and supports filtering by kind/feature or matching webhook provider + event type. Hosts can either enumerate engines (dynamic) or resolve known descriptors directly (static, isolation-focused deployments), and use the exposed manifests (including `RequiredServices`) to ensure all dependencies are available before wiring engines into request or worker pipelines.
+
+## Adapter roles
+
+Adapters remain optional: they map transport concerns to engines while keeping the engines themselves unaware of ASP.NET, MVC, or Razor. Reference adapters include:
+- `UiEngineAdapter` → executes an `IUiEngine` and surfaces `UiAdapterResponse` with typed navigation tokens.
+- `WebhookEngineAdapter` → validates signatures, enforces idempotency hints, and dispatches to `IWebhookEngine` instances.
+
+## Versioning and isolation
+
+Each engine version is tracked in its manifest. Because descriptors are strongly typed and module-owned, a module can expose multiple UI or webhook engines while remaining an isolation boundary. Hosts that do not require dynamic discovery can register known descriptors directly and resolve them through the discovery service using the explicit generic overloads.
diff --git a/src/Bravellian.Platform.Modularity.Api/ApiModuleServiceCollectionExtensions.cs b/src/Bravellian.Platform.Modularity.Api/ApiModuleServiceCollectionExtensions.cs
index 7f1854ca..89dfbcfe 100644
--- a/src/Bravellian.Platform.Modularity.Api/ApiModuleServiceCollectionExtensions.cs
+++ b/src/Bravellian.Platform.Modularity.Api/ApiModuleServiceCollectionExtensions.cs
@@ -39,6 +39,8 @@ public static IServiceCollection AddApiModuleServices(
             services.AddSingleton(module);
         }
 
+        services.AddSingleton<ModuleEngineDiscoveryService>();
+
         return services;
     }
 
diff --git a/src/Bravellian.Platform.Modularity.Api/IWebhookSignatureValidator.cs b/src/Bravellian.Platform.Modularity.Api/IWebhookSignatureValidator.cs
new file mode 100644
index 00000000..ce7dd1fb
--- /dev/null
+++ b/src/Bravellian.Platform.Modularity.Api/IWebhookSignatureValidator.cs
@@ -0,0 +1,26 @@
+// Copyright (c) Bravellian
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Bravellian.Platform.Modularity;
+
+/// <summary>
+/// Validates webhook signatures for adapters.
+/// </summary>
+public interface IWebhookSignatureValidator
+{
+    /// <summary>
+    /// Validates the signature for the provided request.
+    /// </summary>
+    bool Validate(ModuleEngineSecurity security, IReadOnlyDictionary<string, string> headers, string rawBody, string? providedSignature);
+}
diff --git a/src/Bravellian.Platform.Modularity.Api/WebhookAdapterRequest.cs b/src/Bravellian.Platform.Modularity.Api/WebhookAdapterRequest.cs
new file mode 100644
index 00000000..099a7534
--- /dev/null
+++ b/src/Bravellian.Platform.Modularity.Api/WebhookAdapterRequest.cs
@@ -0,0 +1,36 @@
+// Copyright (c) Bravellian
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Bravellian.Platform.Modularity;
+
+/// <summary>
+/// Raw webhook request envelope understood by the transport adapters.
+/// </summary>
+/// <param name="Provider">Webhook provider identifier.</param>
+/// <param name="EventType">Webhook event type.</param>
+/// <param name="Headers">Raw headers supplied by the gateway.</param>
+/// <param name="RawBody">Raw body text for signature validation.</param>
+/// <param name="IdempotencyKey">Idempotency key supplied by provider.</param>
+/// <param name="Attempt">Delivery attempt number.</param>
+/// <param name="Signature">Optional supplied signature.</param>
+/// <param name="Payload">Parsed payload DTO.</param>
+public sealed record WebhookAdapterRequest<TPayload>(
+    string Provider,
+    string EventType,
+    IReadOnlyDictionary<string, string> Headers,
+    string RawBody,
+    string IdempotencyKey,
+    int Attempt,
+    string? Signature,
+    TPayload Payload);
diff --git a/src/Bravellian.Platform.Modularity.Api/WebhookAdapterResponse.cs b/src/Bravellian.Platform.Modularity.Api/WebhookAdapterResponse.cs
new file mode 100644
index 00000000..e7b1c46a
--- /dev/null
+++ b/src/Bravellian.Platform.Modularity.Api/WebhookAdapterResponse.cs
@@ -0,0 +1,23 @@
+// Copyright (c) Bravellian
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Bravellian.Platform.Modularity;
+
+/// <summary>
+/// Adapter response that can be mapped to HTTP or queue responses.
+/// </summary>
+/// <param name="Outcome">Outcome the transport should emit.</param>
+/// <param name="Reason">Optional reason for retries.</param>
+/// <param name="EnqueuedEvent">Optional event payload to enqueue downstream.</param>
+public sealed record WebhookAdapterResponse(WebhookOutcomeType Outcome, string? Reason = null, object? EnqueuedEvent = null);
diff --git a/src/Bravellian.Platform.Modularity.Api/WebhookEngineAdapter.cs b/src/Bravellian.Platform.Modularity.Api/WebhookEngineAdapter.cs
new file mode 100644
index 00000000..c99a58d7
--- /dev/null
+++ b/src/Bravellian.Platform.Modularity.Api/WebhookEngineAdapter.cs
@@ -0,0 +1,152 @@
+// Copyright (c) Bravellian
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Bravellian.Platform.Modularity;
+
+/// <summary>
+/// Adapter that connects webhook engines to HTTP-style transports.
+/// </summary>
+public sealed class WebhookEngineAdapter
+{
+    private readonly ModuleEngineDiscoveryService discovery;
+    private readonly IServiceProvider services;
+    private readonly IWebhookSignatureValidator signatureValidator;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="WebhookEngineAdapter"/> class.
+    /// </summary>
+    public WebhookEngineAdapter(ModuleEngineDiscoveryService discovery, IServiceProvider services, IWebhookSignatureValidator signatureValidator)
+    {
+        this.discovery = discovery;
+        this.services = services;
+        this.signatureValidator = signatureValidator;
+    }
+
+    /// <summary>
+    /// Dispatches a webhook request to a registered engine.
+    /// </summary>
+    public async Task<WebhookAdapterResponse> DispatchAsync<TPayload>(WebhookAdapterRequest<TPayload> request, CancellationToken cancellationToken)
+    {
+        if (request is null)
+        {
+            throw new ArgumentNullException(nameof(request));
+        }
+
+        if (string.IsNullOrWhiteSpace(request.Provider))
+        {
+            throw new ArgumentException("Provider must be a non-empty, non-whitespace string.", nameof(request.Provider));
+        }
+
+        if (string.IsNullOrWhiteSpace(request.EventType))
+        {
+            throw new ArgumentException("EventType must be a non-empty, non-whitespace string.", nameof(request.EventType));
+        }
+
+        var descriptor = discovery.ResolveWebhookEngine(request.Provider, request.EventType)
+            ?? throw new InvalidOperationException($"No webhook engine registered for provider '{request.Provider}' and event '{request.EventType}'.");
+
+        if (descriptor.Manifest.Security is { } security &&
+            !signatureValidator.Validate(security, request.Headers, request.RawBody, request.Signature))
+        {
+            return new WebhookAdapterResponse(
+                WebhookOutcomeType.Acknowledge,
+                $"Signature validation failed. Expected algorithm: {security.SignatureAlgorithm}.");
+        }
+
+        if (string.IsNullOrWhiteSpace(request.IdempotencyKey) && descriptor.Manifest.Security?.IdempotencyWindow is not null)
+        {
+            return new WebhookAdapterResponse(
+                WebhookOutcomeType.Retry,
+                "Idempotency key is required when an idempotency window is configured for this provider.");
+        }
+
+        ValidateRequiredServices(descriptor, request.Provider, request.EventType);
+
+        var typedDescriptor = descriptor as ModuleEngineDescriptor<IWebhookEngine<TPayload>>
+            ?? throw new InvalidOperationException($"Engine '{descriptor.Manifest.Id}' does not implement expected webhook contract.");
+
+        var engine = discovery.ResolveEngine(typedDescriptor, services);
+
+        var outcome = await engine.HandleAsync(
+            new WebhookRequest<TPayload>(request.Provider, request.EventType, request.Payload, request.IdempotencyKey, request.Attempt),
+            cancellationToken).ConfigureAwait(false);
+
+        return new WebhookAdapterResponse(outcome.Outcome, outcome.Reason, outcome.EnqueuedEvent);
+    }
+
+    private void ValidateRequiredServices(IModuleEngineDescriptor descriptor, string provider, string eventType)
+    {
+        var requiredServices = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+        if (descriptor.Manifest.RequiredServices is { Count: > 0 } manifestRequired)
+        {
+            foreach (var service in manifestRequired)
+            {
+                requiredServices.Add(service);
+            }
+        }
+
+        if (descriptor.Manifest.WebhookMetadata is { } metadata)
+        {
+            foreach (var entry in metadata)
+            {
+                if (!string.Equals(entry.Provider, provider, StringComparison.OrdinalIgnoreCase)
+                    || !string.Equals(entry.EventType, eventType, StringComparison.OrdinalIgnoreCase))
+                {
+                    continue;
+                }
+
+                if (entry.RequiredServices is null)
+                {
+                    continue;
+                }
+
+                foreach (var service in entry.RequiredServices)
+                {
+                    requiredServices.Add(service);
+                }
+            }
+        }
+
+        if (requiredServices.Count == 0)
+        {
+            return;
+        }
+
+        foreach (var service in requiredServices)
+        {
+            if (string.IsNullOrWhiteSpace(service))
+            {
+                throw new InvalidOperationException(
+                    $"Engine '{descriptor.ModuleKey}/{descriptor.Manifest.Id}' declares an empty required service identifier.");
+            }
+        }
+
+        var validator = services.GetService<IRequiredServiceValidator>();
+        if (validator is null)
+        {
+            throw new InvalidOperationException(
+                $"Engine '{descriptor.ModuleKey}/{descriptor.Manifest.Id}' declares required services but no {nameof(IRequiredServiceValidator)} is registered.");
+        }
+
+        var missing = validator.GetMissingServices(requiredServices.ToArray()) ?? Array.Empty<string>();
+        if (missing.Count > 0)
+        {
+            throw new InvalidOperationException(
+                $"Engine '{descriptor.ModuleKey}/{descriptor.Manifest.Id}' is missing required services: {string.Join(", ", missing)}.");
+        }
+    }
+}
diff --git a/src/Bravellian.Platform.Modularity.Core/BackgroundModuleServiceCollectionExtensions.cs b/src/Bravellian.Platform.Modularity.Core/BackgroundModuleServiceCollectionExtensions.cs
index 584991cf..1fc432cd 100644
--- a/src/Bravellian.Platform.Modularity.Core/BackgroundModuleServiceCollectionExtensions.cs
+++ b/src/Bravellian.Platform.Modularity.Core/BackgroundModuleServiceCollectionExtensions.cs
@@ -32,6 +32,7 @@ public static IServiceCollection AddBackgroundModuleServices(
         ILoggerFactory? loggerFactory = null)
     {
         ModuleRegistry.InitializeModules<IBackgroundModule>(ModuleCategory.Background, configuration, services, loggerFactory);
+        services.AddSingleton<ModuleEngineDiscoveryService>();
         return services;
     }
 }
diff --git a/src/Bravellian.Platform.Modularity.Core/EngineKind.cs b/src/Bravellian.Platform.Modularity.Core/EngineKind.cs
new file mode 100644
index 00000000..c41ae806
--- /dev/null
+++ b/src/Bravellian.Platform.Modularity.Core/EngineKind.cs
@@ -0,0 +1,31 @@
+// Copyright (c) Bravellian
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Bravellian.Platform.Modularity;
+
+/// <summary>
+/// Supported engine types. Engines are framework-agnostic and must not depend on transport concerns.
+/// </summary>
+public enum EngineKind
+{
+    /// <summary>
+    /// UI-first engines that produce view models and navigation outcomes.
+    /// </summary>
+    Ui,
+
+    /// <summary>
+    /// Webhook engines that react to external callbacks.
+    /// </summary>
+    Webhook,
+}
diff --git a/src/Bravellian.Platform.Modularity.Core/IEngineModule.cs b/src/Bravellian.Platform.Modularity.Core/IEngineModule.cs
new file mode 100644
index 00000000..f7ce6ff4
--- /dev/null
+++ b/src/Bravellian.Platform.Modularity.Core/IEngineModule.cs
@@ -0,0 +1,26 @@
+// Copyright (c) Bravellian
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Bravellian.Platform.Modularity;
+
+/// <summary>
+/// Marker interface for modules that expose engines.
+/// </summary>
+public interface IEngineModule
+{
+    /// <summary>
+    /// Provides engine descriptors for the module.
+    /// </summary>
+    IEnumerable<IModuleEngineDescriptor> DescribeEngines();
+}
diff --git a/src/Bravellian.Platform.Modularity.Core/IModuleEngineDescriptor.cs b/src/Bravellian.Platform.Modularity.Core/IModuleEngineDescriptor.cs
new file mode 100644
index 00000000..f5fba09c
--- /dev/null
+++ b/src/Bravellian.Platform.Modularity.Core/IModuleEngineDescriptor.cs
@@ -0,0 +1,29 @@
+// Copyright (c) Bravellian
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Bravellian.Platform.Modularity;
+
+/// <summary>
+/// Base abstraction for an engine descriptor. Implementations should remain transport agnostic.
+/// </summary>
+public interface IModuleEngineDescriptor
+{
+    string ModuleKey { get; }
+
+    ModuleEngineManifest Manifest { get; }
+
+    Type ContractType { get; }
+
+    object? Create(IServiceProvider serviceProvider);
+}
diff --git a/src/Bravellian.Platform.Modularity.Core/IRequiredServiceValidator.cs b/src/Bravellian.Platform.Modularity.Core/IRequiredServiceValidator.cs
new file mode 100644
index 00000000..0e843570
--- /dev/null
+++ b/src/Bravellian.Platform.Modularity.Core/IRequiredServiceValidator.cs
@@ -0,0 +1,26 @@
+// Copyright (c) Bravellian
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Bravellian.Platform.Modularity;
+
+/// <summary>
+/// Validates that required engine services are available for a host.
+/// </summary>
+public interface IRequiredServiceValidator
+{
+    /// <summary>
+    /// Returns the subset of required services that are missing.
+    /// </summary>
+    IReadOnlyCollection<string> GetMissingServices(IReadOnlyCollection<string> requiredServices);
+}
diff --git a/src/Bravellian.Platform.Modularity.Core/IUiEngine.cs b/src/Bravellian.Platform.Modularity.Core/IUiEngine.cs
new file mode 100644
index 00000000..bbf73904
--- /dev/null
+++ b/src/Bravellian.Platform.Modularity.Core/IUiEngine.cs
@@ -0,0 +1,31 @@
+// Copyright (c) Bravellian
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Bravellian.Platform.Modularity;
+
+/// <summary>
+/// Generic UI engine contract that operates on DTOs and produces view models.
+/// </summary>
+/// <typeparam name="TInput">Input DTO.</typeparam>
+/// <typeparam name="TViewModel">View model output.</typeparam>
+public interface IUiEngine<TInput, TViewModel>
+{
+    /// <summary>
+    /// Executes the engine using the provided command DTO.
+    /// </summary>
+    /// <param name="command">Command DTO.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>A view model and any navigation tokens emitted.</returns>
+    Task<UiEngineResult<TViewModel>> ExecuteAsync(TInput command, CancellationToken cancellationToken);
+}
diff --git a/src/Bravellian.Platform.Modularity.Core/IWebhookEngine.cs b/src/Bravellian.Platform.Modularity.Core/IWebhookEngine.cs
new file mode 100644
index 00000000..0bc25cb8
--- /dev/null
+++ b/src/Bravellian.Platform.Modularity.Core/IWebhookEngine.cs
@@ -0,0 +1,27 @@
+// Copyright (c) Bravellian
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Bravellian.Platform.Modularity;
+
+/// <summary>
+/// Webhook engine contract. Engines decide the outcome without transport coupling.
+/// </summary>
+/// <typeparam name="TPayload">Webhook payload type.</typeparam>
+public interface IWebhookEngine<TPayload>
+{
+    /// <summary>
+    /// Handles a webhook request.
+    /// </summary>
+    Task<WebhookOutcome> HandleAsync(WebhookRequest<TPayload> request, CancellationToken cancellationToken);
+}
diff --git a/src/Bravellian.Platform.Modularity.Core/ModuleEngineAdapterHints.cs b/src/Bravellian.Platform.Modularity.Core/ModuleEngineAdapterHints.cs
new file mode 100644
index 00000000..40868005
--- /dev/null
+++ b/src/Bravellian.Platform.Modularity.Core/ModuleEngineAdapterHints.cs
@@ -0,0 +1,30 @@
+// Copyright (c) Bravellian
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Bravellian.Platform.Modularity;
+
+/// <summary>
+/// Adapter-level hints used by hosts to wire up engines to transports.
+/// </summary>
+/// <param name="RequiresRawRequestBody">True if the adapter must expose the raw request body to the engine.</param>
+/// <param name="RequiresRawHeaders">True if the adapter must expose raw headers.</param>
+/// <param name="SupportsChallengeResponses">True if the adapter should support verification/challenge responses.</param>
+/// <param name="RequiresAuthenticatedUser">True if the adapter must enforce authentication.</param>
+/// <param name="RequiresTenantContext">True if the adapter must enforce tenancy.</param>
+public sealed record ModuleEngineAdapterHints(
+    bool RequiresRawRequestBody = false,
+    bool RequiresRawHeaders = false,
+    bool SupportsChallengeResponses = false,
+    bool RequiresAuthenticatedUser = false,
+    bool RequiresTenantContext = false);
diff --git a/src/Bravellian.Platform.Modularity.Core/ModuleEngineCapabilities.cs b/src/Bravellian.Platform.Modularity.Core/ModuleEngineCapabilities.cs
new file mode 100644
index 00000000..0eb9d378
--- /dev/null
+++ b/src/Bravellian.Platform.Modularity.Core/ModuleEngineCapabilities.cs
@@ -0,0 +1,28 @@
+// Copyright (c) Bravellian
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Bravellian.Platform.Modularity;
+
+/// <summary>
+/// Declares the actions and events an engine can process.
+/// </summary>
+/// <param name="Actions">Named commands/actions the engine supports.</param>
+/// <param name="Events">Events emitted by the engine.</param>
+/// <param name="SupportsAsync">Reserved for future use. Engines are currently Task-based and adapters ignore this flag; it exists to allow hosts to distinguish async vs. sync execution if synchronous engines are introduced later.</param>
+/// <param name="SupportsStreaming">Indicates streaming updates are supported.</param>
+public sealed record ModuleEngineCapabilities(
+    IReadOnlyCollection<string> Actions,
+    IReadOnlyCollection<string> Events,
+    bool SupportsAsync = true,
+    bool SupportsStreaming = false);
diff --git a/src/Bravellian.Platform.Modularity.Core/ModuleEngineCompatibility.cs b/src/Bravellian.Platform.Modularity.Core/ModuleEngineCompatibility.cs
new file mode 100644
index 00000000..aadfd600
--- /dev/null
+++ b/src/Bravellian.Platform.Modularity.Core/ModuleEngineCompatibility.cs
@@ -0,0 +1,22 @@
+// Copyright (c) Bravellian
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Bravellian.Platform.Modularity;
+
+/// <summary>
+/// Compatibility metadata for engine evolution.
+/// </summary>
+/// <param name="MinHostVersion">Minimum host version required.</param>
+/// <param name="BreakingChanges">Human-readable notes for breaking changes.</param>
+public sealed record ModuleEngineCompatibility(string? MinHostVersion, string? BreakingChanges);
diff --git a/src/Bravellian.Platform.Modularity.Core/ModuleEngineDescriptor.cs b/src/Bravellian.Platform.Modularity.Core/ModuleEngineDescriptor.cs
new file mode 100644
index 00000000..225ae28e
--- /dev/null
+++ b/src/Bravellian.Platform.Modularity.Core/ModuleEngineDescriptor.cs
@@ -0,0 +1,32 @@
+// Copyright (c) Bravellian
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Bravellian.Platform.Modularity;
+
+/// <summary>
+/// Strongly typed engine descriptor registered by a module. Factories are provided by modules and consumed by adapters/hosts.
+/// </summary>
+/// <typeparam name="TContract">Engine contract interface (e.g., <see cref="IUiEngine{TInput, TResult}"/>).</typeparam>
+/// <param name="ModuleKey">Module key that owns the engine.</param>
+/// <param name="Manifest">Engine manifest metadata.</param>
+/// <param name="Factory">Factory that resolves the engine instance from an <see cref="IServiceProvider"/>.</param>
+public sealed record ModuleEngineDescriptor<TContract>(
+    string ModuleKey,
+    ModuleEngineManifest Manifest,
+    Func<IServiceProvider, TContract> Factory) : IModuleEngineDescriptor where TContract : notnull
+{
+    public Type ContractType => typeof(TContract);
+
+    public object? Create(IServiceProvider serviceProvider) => Factory(serviceProvider);
+}
diff --git a/src/Bravellian.Platform.Modularity.Core/ModuleEngineDiscoveryService.cs b/src/Bravellian.Platform.Modularity.Core/ModuleEngineDiscoveryService.cs
new file mode 100644
index 00000000..03ed483a
--- /dev/null
+++ b/src/Bravellian.Platform.Modularity.Core/ModuleEngineDiscoveryService.cs
@@ -0,0 +1,89 @@
+// Copyright (c) Bravellian
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Bravellian.Platform.Modularity;
+
+/// <summary>
+/// Engine discovery service used by adapters and hosts.
+/// </summary>
+public sealed class ModuleEngineDiscoveryService
+{
+    /// <summary>
+    /// Lists all engines registered by modules.
+    /// </summary>
+    public IReadOnlyCollection<IModuleEngineDescriptor> List() => ModuleEngineRegistry.GetEngines();
+
+    /// <summary>
+    /// Lists engines filtered by kind or feature area.
+    /// </summary>
+    public IReadOnlyCollection<IModuleEngineDescriptor> List(EngineKind? kind, string? featureArea = null)
+    {
+        return ModuleEngineRegistry.GetEngines()
+            .Where(e => (!kind.HasValue || e.Manifest.Kind == kind.Value)
+                     && (featureArea is null || string.Equals(e.Manifest.FeatureArea, featureArea, StringComparison.OrdinalIgnoreCase)))
+            .ToArray();
+    }
+
+    /// <summary>
+    /// Resolves a webhook engine by provider and event type.
+    /// </summary>
+    public IModuleEngineDescriptor? ResolveWebhookEngine(string provider, string eventType) => ModuleEngineRegistry.FindWebhookEngine(provider, eventType);
+
+    /// <summary>
+    /// Resolves an engine descriptor by module and engine identifier.
+    /// </summary>
+    public IModuleEngineDescriptor? ResolveById(string moduleKey, string engineId) => ModuleEngineRegistry.FindById(moduleKey, engineId);
+
+    /// <summary>
+    /// Resolves an engine instance for a descriptor.
+    /// </summary>
+    public TContract ResolveEngine<TContract>(ModuleEngineDescriptor<TContract> descriptor, IServiceProvider serviceProvider)
+        where TContract : notnull
+    {
+        if (serviceProvider is null)
+        {
+            throw new ArgumentNullException(nameof(serviceProvider));
+        }
+
+        var instance = descriptor.Factory(serviceProvider);
+
+        if (instance is null)
+        {
+            throw new System.InvalidOperationException(
+                $"The factory for module engine '{descriptor.ModuleKey}/{descriptor.Manifest.Id}' returned null.");
+        }
+
+        return instance;
+    }
+    /// <summary>
+    /// Resolves an engine instance for a descriptor when only the contract type is known at runtime.
+    /// </summary>
+    public object ResolveEngine(IModuleEngineDescriptor descriptor, IServiceProvider serviceProvider)
+    {
+        if (serviceProvider is null)
+        {
+            throw new ArgumentNullException(nameof(serviceProvider));
+        }
+
+        var instance = descriptor.Create(serviceProvider);
+
+        if (instance is null)
+        {
+            throw new InvalidOperationException(
+                $"The factory for module engine '{descriptor.ModuleKey}/{descriptor.Manifest.Id}' returned null.");
+        }
+
+        return instance;
+    }
+}
diff --git a/src/Bravellian.Platform.Modularity.Core/ModuleEngineManifest.cs b/src/Bravellian.Platform.Modularity.Core/ModuleEngineManifest.cs
new file mode 100644
index 00000000..d7a98d28
--- /dev/null
+++ b/src/Bravellian.Platform.Modularity.Core/ModuleEngineManifest.cs
@@ -0,0 +1,48 @@
+// Copyright (c) Bravellian
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Bravellian.Platform.Modularity;
+
+/// <summary>
+/// Describes a module engine in a transport-agnostic manner.
+/// </summary>
+/// <param name="Id">Engine identifier scoped to the module.</param>
+/// <param name="Version">Contract version for the engine.</param>
+/// <param name="Description">Human readable description.</param>
+/// <param name="Kind">Engine kind (UI or webhook).</param>
+/// <param name="FeatureArea">Optional feature area/page grouping.</param>
+/// <param name="Capabilities">Action/event capabilities.</param>
+/// <param name="Inputs">Input schemas.</param>
+/// <param name="Outputs">Output schemas.</param>
+/// <param name="NavigationHints">Navigation tokens understood by adapters.</param>
+/// <param name="RequiredServices">Services the host must supply via DI.</param>
+/// <param name="AdapterHints">Transport-level hints for adapters.</param>
+/// <param name="Security">Security metadata, typically for webhook engines.</param>
+/// <param name="Compatibility">Compatibility and version notes.</param>
+/// <param name="WebhookMetadata">Webhook event metadata advertised by the engine.</param>
+public sealed record ModuleEngineManifest(
+    string Id,
+    string Version,
+    string Description,
+    EngineKind Kind,
+    string? FeatureArea = null,
+    ModuleEngineCapabilities? Capabilities = null,
+    IReadOnlyCollection<ModuleEngineSchema>? Inputs = null,
+    IReadOnlyCollection<ModuleEngineSchema>? Outputs = null,
+    ModuleEngineNavigationHints? NavigationHints = null,
+    IReadOnlyCollection<string>? RequiredServices = null,
+    ModuleEngineAdapterHints? AdapterHints = null,
+    ModuleEngineSecurity? Security = null,
+    ModuleEngineCompatibility? Compatibility = null,
+    IReadOnlyCollection<ModuleEngineWebhookMetadata>? WebhookMetadata = null);
diff --git a/src/Bravellian.Platform.Modularity.Core/ModuleEngineNavigationHints.cs b/src/Bravellian.Platform.Modularity.Core/ModuleEngineNavigationHints.cs
new file mode 100644
index 00000000..83e663ec
--- /dev/null
+++ b/src/Bravellian.Platform.Modularity.Core/ModuleEngineNavigationHints.cs
@@ -0,0 +1,21 @@
+// Copyright (c) Bravellian
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Bravellian.Platform.Modularity;
+
+/// <summary>
+/// Navigation hints are abstract tokens adapters map to routes, dialogs, or screens.
+/// </summary>
+/// <param name="Tokens">Well-known navigation tokens emitted by the engine.</param>
+public sealed record ModuleEngineNavigationHints(IReadOnlyCollection<ModuleNavigationToken> Tokens);
diff --git a/src/Bravellian.Platform.Modularity.Core/ModuleEngineRegistry.cs b/src/Bravellian.Platform.Modularity.Core/ModuleEngineRegistry.cs
new file mode 100644
index 00000000..150c28a1
--- /dev/null
+++ b/src/Bravellian.Platform.Modularity.Core/ModuleEngineRegistry.cs
@@ -0,0 +1,190 @@
+// Copyright (c) Bravellian
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System.Collections.Concurrent;
+
+namespace Bravellian.Platform.Modularity;
+
+/// <summary>
+/// Registry for transport-agnostic module engines.
+/// </summary>
+internal static class ModuleEngineRegistry
+{
+    private static readonly ConcurrentDictionary<string, List<IModuleEngineDescriptor>> Engines = new(StringComparer.OrdinalIgnoreCase);
+    
+    // Single lock protects registry operations without disposal requirements.
+    private static readonly Lock RegistryLock = new();
+    private static IModuleEngineDescriptor[]? CachedSnapshot;
+
+    public static void Register(string moduleKey, IEnumerable<IModuleEngineDescriptor> descriptors)
+    {
+        lock (RegistryLock)
+        {
+            var list = Engines.GetOrAdd(moduleKey, _ => new List<IModuleEngineDescriptor>());
+            foreach (var descriptor in descriptors)
+            {
+                ValidateWebhookMetadataUniqueness(descriptor);
+                var exists = list.Any(existing => string.Equals(existing.ModuleKey, descriptor.ModuleKey, StringComparison.OrdinalIgnoreCase)
+                                                && string.Equals(existing.Manifest.Id, descriptor.Manifest.Id, StringComparison.OrdinalIgnoreCase)
+                                                && existing.ContractType == descriptor.ContractType);
+                if (!exists)
+                {
+                    list.Add(descriptor);
+                }
+            }
+
+            CachedSnapshot = null;
+        }
+    }
+
+    private static void ValidateWebhookMetadataUniqueness(IModuleEngineDescriptor descriptor)
+    {
+        var metadata = descriptor.Manifest.WebhookMetadata;
+        if (metadata is null)
+        {
+            return;
+        }
+
+        var seen = new HashSet<(string Provider, string EventType)>(new WebhookMetadataKeyComparer());
+
+        foreach (var entry in metadata)
+        {
+            if (!seen.Add((entry.Provider, entry.EventType)))
+            {
+                throw new InvalidOperationException(
+                    $"Engine '{descriptor.ModuleKey}/{descriptor.Manifest.Id}' declares duplicate webhook metadata for provider '{entry.Provider}' and event '{entry.EventType}'.");
+            }
+
+            foreach (var existingList in Engines.Values)
+            {
+                foreach (var existing in existingList)
+                {
+                    if (existing.Manifest.WebhookMetadata is null)
+                    {
+                        continue;
+                    }
+
+                    foreach (var existingEntry in existing.Manifest.WebhookMetadata)
+                    {
+                        if (string.Equals(existingEntry.Provider, entry.Provider, StringComparison.OrdinalIgnoreCase)
+                            && string.Equals(existingEntry.EventType, entry.EventType, StringComparison.OrdinalIgnoreCase))
+                        {
+                            throw new InvalidOperationException(
+                                $"Webhook provider '{entry.Provider}' and event '{entry.EventType}' are already handled by engine '{existing.ModuleKey}/{existing.Manifest.Id}'.");
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private sealed class WebhookMetadataKeyComparer : IEqualityComparer<(string Provider, string EventType)>
+    {
+        public bool Equals((string Provider, string EventType) x, (string Provider, string EventType) y)
+        {
+            return string.Equals(x.Provider, y.Provider, StringComparison.OrdinalIgnoreCase)
+                && string.Equals(x.EventType, y.EventType, StringComparison.OrdinalIgnoreCase);
+        }
+
+        public int GetHashCode((string Provider, string EventType) obj)
+        {
+            return HashCode.Combine(
+                StringComparer.OrdinalIgnoreCase.GetHashCode(obj.Provider ?? string.Empty),
+                StringComparer.OrdinalIgnoreCase.GetHashCode(obj.EventType ?? string.Empty));
+        }
+    }
+
+    public static IReadOnlyCollection<IModuleEngineDescriptor> GetEngines()
+    {
+        lock (RegistryLock)
+        {
+            if (CachedSnapshot is { } cached)
+            {
+                return cached;
+            }
+
+            // Snapshot the engine lists while holding the lock to avoid races with registry mutations.
+            var lists = Engines.Values.ToArray();
+            cached = lists.SelectMany(list => list).ToArray();
+            CachedSnapshot = cached;
+            return cached;
+        }
+    }
+
+    public static IModuleEngineDescriptor? FindWebhookEngine(string provider, string eventType)
+    {
+        lock (RegistryLock)
+        {
+            // Search for webhook engine matching the provider and event type.
+            foreach (var list in Engines.Values)
+            {
+                foreach (var descriptor in list)
+                {
+                    if (descriptor.Manifest.Kind != EngineKind.Webhook)
+                    {
+                        continue;
+                    }
+
+                    var metadataCollection = descriptor.Manifest.WebhookMetadata;
+                    if (metadataCollection == null)
+                    {
+                        continue;
+                    }
+
+                    foreach (var meta in metadataCollection)
+                    {
+                        if (string.Equals(meta.Provider, provider, StringComparison.OrdinalIgnoreCase)
+                            && string.Equals(meta.EventType, eventType, StringComparison.OrdinalIgnoreCase))
+                        {
+                            return descriptor;
+                        }
+                    }
+                }
+            }
+
+            return null;
+        }
+    }
+
+    public static IModuleEngineDescriptor? FindById(string moduleKey, string engineId)
+    {
+        lock (RegistryLock)
+        {
+            // Narrow the lookup to the specific moduleKey.
+            if (!Engines.TryGetValue(moduleKey, out var list))
+            {
+                return null;
+            }
+
+            foreach (var descriptor in list)
+            {
+                if (string.Equals(descriptor.Manifest.Id, engineId, StringComparison.OrdinalIgnoreCase))
+                {
+                    return descriptor;
+                }
+            }
+
+            return null;
+        }
+    }
+
+    public static void Reset()
+    {
+        lock (RegistryLock)
+        {
+            Engines.Clear();
+            CachedSnapshot = null;
+        }
+    }
+}
diff --git a/src/Bravellian.Platform.Modularity.Core/ModuleEngineSchema.cs b/src/Bravellian.Platform.Modularity.Core/ModuleEngineSchema.cs
new file mode 100644
index 00000000..65b904b9
--- /dev/null
+++ b/src/Bravellian.Platform.Modularity.Core/ModuleEngineSchema.cs
@@ -0,0 +1,23 @@
+// Copyright (c) Bravellian
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Bravellian.Platform.Modularity;
+
+/// <summary>
+/// Declares schema hints for engine inputs or outputs.
+/// </summary>
+/// <param name="Name">Schema name or role (e.g., "command", "payload").</param>
+/// <param name="ClrType">Associated CLR type for serialization.</param>
+/// <param name="Notes">Additional notes or validation hints.</param>
+public sealed record ModuleEngineSchema(string Name, Type ClrType, string? Notes = null);
diff --git a/src/Bravellian.Platform.Modularity.Core/ModuleEngineSecurity.cs b/src/Bravellian.Platform.Modularity.Core/ModuleEngineSecurity.cs
new file mode 100644
index 00000000..7f33dff7
--- /dev/null
+++ b/src/Bravellian.Platform.Modularity.Core/ModuleEngineSecurity.cs
@@ -0,0 +1,26 @@
+// Copyright (c) Bravellian
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Bravellian.Platform.Modularity;
+
+/// <summary>
+/// Security metadata used by adapters for validation.
+/// </summary>
+/// <param name="SignatureAlgorithm">Expected signature algorithm (e.g., HMAC-SHA256).</param>
+/// <param name="SecretScope">Scope/identifier for retrieving secrets.</param>
+/// <param name="IdempotencyWindow">Optional idempotency window hint.</param>
+public sealed record ModuleEngineSecurity(
+    ModuleSignatureAlgorithm SignatureAlgorithm,
+    string SecretScope,
+    TimeSpan? IdempotencyWindow = null);
diff --git a/src/Bravellian.Platform.Modularity.Core/ModuleEngineWebhookMetadata.cs b/src/Bravellian.Platform.Modularity.Core/ModuleEngineWebhookMetadata.cs
new file mode 100644
index 00000000..3aee88c0
--- /dev/null
+++ b/src/Bravellian.Platform.Modularity.Core/ModuleEngineWebhookMetadata.cs
@@ -0,0 +1,30 @@
+// Copyright (c) Bravellian
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Bravellian.Platform.Modularity;
+
+/// <summary>
+/// Webhook event metadata advertised by webhook engines.
+/// </summary>
+/// <param name="Provider">Source provider of the webhook (e.g., Postmark).</param>
+/// <param name="EventType">Event type identifier.</param>
+/// <param name="PayloadSchema">Payload schema type.</param>
+/// <param name="RequiredServices">Services required for dispatch.</param>
+/// <param name="Retries">Retry policy hint.</param>
+public sealed record ModuleEngineWebhookMetadata(
+    string Provider,
+    string EventType,
+    ModuleEngineSchema PayloadSchema,
+    IReadOnlyCollection<string>? RequiredServices = null,
+    int? Retries = null);
diff --git a/src/Bravellian.Platform.Modularity.Core/ModuleNavigationToken.cs b/src/Bravellian.Platform.Modularity.Core/ModuleNavigationToken.cs
new file mode 100644
index 00000000..594e8a72
--- /dev/null
+++ b/src/Bravellian.Platform.Modularity.Core/ModuleNavigationToken.cs
@@ -0,0 +1,20 @@
+// Copyright (c) Bravellian
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Bravellian.Platform.Modularity;
+
+/// <summary>
+/// Typed navigation token an engine can emit. Adapters map these to concrete routes, dialogs, or screens.
+/// </summary>
+public sealed record ModuleNavigationToken(string Token, NavigationTargetKind TargetKind, string? Description = null);
diff --git a/src/Bravellian.Platform.Modularity.Core/ModuleRegistry.cs b/src/Bravellian.Platform.Modularity.Core/ModuleRegistry.cs
index 0d17ce53..e2e41876 100644
--- a/src/Bravellian.Platform.Modularity.Core/ModuleRegistry.cs
+++ b/src/Bravellian.Platform.Modularity.Core/ModuleRegistry.cs
@@ -81,6 +81,25 @@ internal static IReadOnlyCollection<TModule> InitializeModules<TModule>(
             var module = (TModule)CreateInstance(type, loggerFactory);
             LoadConfiguration(configuration, module, loggerFactory);
             RegisterInstance(module);
+            if (module is IEngineModule engineModule)
+            {
+                var descriptors = engineModule
+                    .DescribeEngines()
+                    .Select(descriptor =>
+                    {
+                        if (!string.Equals(descriptor.ModuleKey, module.Key, StringComparison.OrdinalIgnoreCase))
+                        {
+                            throw new InvalidOperationException(
+                                $"Engine descriptor module key '{descriptor.ModuleKey}' must match its owning module key '{module.Key}'. " +
+                                "Engine descriptors must use their owning module's key to ensure proper isolation and discovery. " +
+                                "Update the engine descriptor's ModuleKey to match the module's Key.");
+                        }
+
+                        return descriptor;
+                    })
+                    .ToArray();
+                ModuleEngineRegistry.Register(module.Key, descriptors);
+            }
             initialized.Add(module);
         }
 
@@ -122,6 +141,7 @@ internal static void Reset()
             }
 
             Instances.Clear();
+            ModuleEngineRegistry.Reset();
         }
     }
 
diff --git a/src/Bravellian.Platform.Modularity.Core/ModuleSignatureAlgorithm.cs b/src/Bravellian.Platform.Modularity.Core/ModuleSignatureAlgorithm.cs
new file mode 100644
index 00000000..ee42f734
--- /dev/null
+++ b/src/Bravellian.Platform.Modularity.Core/ModuleSignatureAlgorithm.cs
@@ -0,0 +1,26 @@
+// Copyright (c) Bravellian
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Bravellian.Platform.Modularity;
+
+/// <summary>
+/// Enumerates supported signature algorithms for webhook verification.
+/// </summary>
+public enum ModuleSignatureAlgorithm
+{
+    None = 0,
+    HmacSha256 = 1,
+    HmacSha512 = 2,
+    RsaSha256 = 3
+}
diff --git a/src/Bravellian.Platform.Modularity.Core/NavigationTargetKind.cs b/src/Bravellian.Platform.Modularity.Core/NavigationTargetKind.cs
new file mode 100644
index 00000000..ad9aade6
--- /dev/null
+++ b/src/Bravellian.Platform.Modularity.Core/NavigationTargetKind.cs
@@ -0,0 +1,26 @@
+// Copyright (c) Bravellian
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Bravellian.Platform.Modularity;
+
+/// <summary>
+/// Enumerates the supported navigation targets that hosts can map to runtime concepts.
+/// </summary>
+public enum NavigationTargetKind
+{
+    Route = 0,
+    Dialog = 1,
+    Component = 2,
+    External = 3
+}
diff --git a/src/Bravellian.Platform.Modularity.Core/UiEngineResult.cs b/src/Bravellian.Platform.Modularity.Core/UiEngineResult.cs
new file mode 100644
index 00000000..d415bce7
--- /dev/null
+++ b/src/Bravellian.Platform.Modularity.Core/UiEngineResult.cs
@@ -0,0 +1,26 @@
+// Copyright (c) Bravellian
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Bravellian.Platform.Modularity;
+
+/// <summary>
+/// UI engine result containing the view model and optional navigation tokens/events.
+/// </summary>
+/// <param name="ViewModel">Resulting view model.</param>
+/// <param name="NavigationTargets">Navigation tokens emitted by the engine.</param>
+/// <param name="Events">Events emitted for adapters to relay.</param>
+public sealed record UiEngineResult<TViewModel>(
+    TViewModel ViewModel,
+    IReadOnlyCollection<ModuleNavigationToken>? NavigationTargets = null,
+    IReadOnlyCollection<string>? Events = null);
diff --git a/src/Bravellian.Platform.Modularity.Core/WebhookOutcome.cs b/src/Bravellian.Platform.Modularity.Core/WebhookOutcome.cs
new file mode 100644
index 00000000..6cd4d688
--- /dev/null
+++ b/src/Bravellian.Platform.Modularity.Core/WebhookOutcome.cs
@@ -0,0 +1,39 @@
+// Copyright (c) Bravellian
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Bravellian.Platform.Modularity;
+
+/// <summary>
+/// Webhook outcome mapped to transport responses by adapters.
+/// </summary>
+/// <param name="Outcome">Outcome type.</param>
+/// <param name="Reason">Optional reason for retries or re-queues.</param>
+/// <param name="EnqueuedEvent">Optional event payload to enqueue downstream.</param>
+public sealed record WebhookOutcome(WebhookOutcomeType Outcome, string? Reason = null, object? EnqueuedEvent = null)
+{
+    /// <summary>
+    /// Creates an acknowledge outcome.
+    /// </summary>
+    public static WebhookOutcome Acknowledge() => new(WebhookOutcomeType.Acknowledge);
+
+    /// <summary>
+    /// Creates a retry outcome.
+    /// </summary>
+    public static WebhookOutcome Retry(string reason) => new(WebhookOutcomeType.Retry, reason);
+
+    /// <summary>
+    /// Creates an enqueue outcome.
+    /// </summary>
+    public static WebhookOutcome Enqueue(object enqueued) => new(WebhookOutcomeType.EnqueueEvent, null, enqueued);
+}
diff --git a/src/Bravellian.Platform.Modularity.Core/WebhookOutcomeType.cs b/src/Bravellian.Platform.Modularity.Core/WebhookOutcomeType.cs
new file mode 100644
index 00000000..97a490b6
--- /dev/null
+++ b/src/Bravellian.Platform.Modularity.Core/WebhookOutcomeType.cs
@@ -0,0 +1,36 @@
+// Copyright (c) Bravellian
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Bravellian.Platform.Modularity;
+
+/// <summary>
+/// Webhook outcome types understood by adapters.
+/// </summary>
+public enum WebhookOutcomeType
+{
+    /// <summary>
+    /// Acknowledge the webhook and stop retries.
+    /// </summary>
+    Acknowledge,
+
+    /// <summary>
+    /// Ask the transport to retry the webhook.
+    /// </summary>
+    Retry,
+
+    /// <summary>
+    /// Enqueue an event internally while acknowledging the webhook.
+    /// </summary>
+    EnqueueEvent,
+}
diff --git a/src/Bravellian.Platform.Modularity.Core/WebhookRequest.cs b/src/Bravellian.Platform.Modularity.Core/WebhookRequest.cs
new file mode 100644
index 00000000..8f8bd6ed
--- /dev/null
+++ b/src/Bravellian.Platform.Modularity.Core/WebhookRequest.cs
@@ -0,0 +1,30 @@
+// Copyright (c) Bravellian
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Bravellian.Platform.Modularity;
+
+/// <summary>
+/// Incoming webhook request passed to webhook engines.
+/// </summary>
+/// <param name="Provider">Provider identifier.</param>
+/// <param name="EventType">Event type identifier.</param>
+/// <param name="Payload">Deserialized payload.</param>
+/// <param name="IdempotencyKey">Idempotency key for replay protection.</param>
+/// <param name="Attempt">Current delivery attempt; 0 means unknown, values >= 1 are attempt counts (first attempt is 1).</param>
+public sealed record WebhookRequest<TPayload>(
+    string Provider,
+    string EventType,
+    TPayload Payload,
+    string IdempotencyKey,
+    int Attempt = 0);
diff --git a/src/Bravellian.Platform.Modularity.FullStack/FullStackModuleServiceCollectionExtensions.cs b/src/Bravellian.Platform.Modularity.FullStack/FullStackModuleServiceCollectionExtensions.cs
index d6546b4d..91da828c 100644
--- a/src/Bravellian.Platform.Modularity.FullStack/FullStackModuleServiceCollectionExtensions.cs
+++ b/src/Bravellian.Platform.Modularity.FullStack/FullStackModuleServiceCollectionExtensions.cs
@@ -42,6 +42,7 @@ public static IServiceCollection AddFullStackModuleServices(
             services.AddSingleton(module);
         }
 
+        services.AddSingleton<ModuleEngineDiscoveryService>();
         services.AddSingleton<ModuleNavigationService>();
         return services;
     }
diff --git a/src/Bravellian.Platform.Modularity.FullStack/UiAdapterResponse.cs b/src/Bravellian.Platform.Modularity.FullStack/UiAdapterResponse.cs
new file mode 100644
index 00000000..fbd75d76
--- /dev/null
+++ b/src/Bravellian.Platform.Modularity.FullStack/UiAdapterResponse.cs
@@ -0,0 +1,26 @@
+// Copyright (c) Bravellian
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Bravellian.Platform.Modularity;
+
+/// <summary>
+/// Adapter response used by UI hosts. Navigation tokens are mapped to routes/pages by the host.
+/// </summary>
+/// <param name="ViewModel">View model emitted by the engine.</param>
+/// <param name="NavigationTargets">Navigation tokens for the host to interpret.</param>
+/// <param name="Events">Domain events emitted by the engine.</param>
+public sealed record UiAdapterResponse<TViewModel>(
+    TViewModel ViewModel,
+    IReadOnlyCollection<ModuleNavigationToken>? NavigationTargets,
+    IReadOnlyCollection<string>? Events);
diff --git a/src/Bravellian.Platform.Modularity.FullStack/UiEngineAdapter.cs b/src/Bravellian.Platform.Modularity.FullStack/UiEngineAdapter.cs
new file mode 100644
index 00000000..69c5a93f
--- /dev/null
+++ b/src/Bravellian.Platform.Modularity.FullStack/UiEngineAdapter.cs
@@ -0,0 +1,101 @@
+// Copyright (c) Bravellian
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Bravellian.Platform.Modularity;
+
+/// <summary>
+/// Adapter that maps UI engine contracts to host navigation tokens.
+/// </summary>
+public sealed class UiEngineAdapter
+{
+    private readonly ModuleEngineDiscoveryService discoveryService;
+    private readonly IServiceProvider services;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="UiEngineAdapter"/> class.
+    /// </summary>
+    public UiEngineAdapter(ModuleEngineDiscoveryService discoveryService, IServiceProvider services)
+    {
+        this.discoveryService = discoveryService;
+        this.services = services;
+    }
+
+    /// <summary>
+    /// Executes a UI engine and returns a transport-ready response.
+    /// </summary>
+    public async Task<UiAdapterResponse<TViewModel>> ExecuteAsync<TInput, TViewModel>(string moduleKey, string engineId, TInput command, CancellationToken cancellationToken)
+    {
+        if (string.IsNullOrWhiteSpace(moduleKey))
+        {
+            throw new ArgumentException("Module key must be a non-empty, non-whitespace string.", nameof(moduleKey));
+        }
+
+        if (string.IsNullOrWhiteSpace(engineId))
+        {
+            throw new ArgumentException("Engine ID must be a non-empty, non-whitespace string.", nameof(engineId));
+        }
+
+        if (command is null)
+        {
+            throw new ArgumentNullException(nameof(command));
+        }
+
+        var descriptor = discoveryService.ResolveById(moduleKey, engineId)
+            ?? throw new InvalidOperationException($"No UI engine registered with id '{engineId}' for module '{moduleKey}'.");
+
+        ValidateRequiredServices(descriptor, descriptor.Manifest.RequiredServices);
+
+        var typedDescriptor = descriptor as ModuleEngineDescriptor<IUiEngine<TInput, TViewModel>>
+            ?? throw new InvalidOperationException($"Engine '{engineId}' does not implement the expected UI contract.");
+
+        var engine = discoveryService.ResolveEngine(typedDescriptor, services);
+
+        var result = await engine.ExecuteAsync(command, cancellationToken).ConfigureAwait(false);
+
+        return new UiAdapterResponse<TViewModel>(result.ViewModel, result.NavigationTargets, result.Events);
+    }
+
+    private void ValidateRequiredServices(IModuleEngineDescriptor descriptor, IReadOnlyCollection<string>? requiredServices)
+    {
+        if (requiredServices is null || requiredServices.Count == 0)
+        {
+            return;
+        }
+
+        foreach (var service in requiredServices)
+        {
+            if (string.IsNullOrWhiteSpace(service))
+            {
+                throw new InvalidOperationException(
+                    $"Engine '{descriptor.ModuleKey}/{descriptor.Manifest.Id}' declares an empty required service identifier.");
+            }
+        }
+
+        var validator = services.GetService<IRequiredServiceValidator>();
+        if (validator is null)
+        {
+            throw new InvalidOperationException(
+                $"Engine '{descriptor.ModuleKey}/{descriptor.Manifest.Id}' declares required services but no {nameof(IRequiredServiceValidator)} is registered.");
+        }
+
+        var missing = validator.GetMissingServices(requiredServices) ?? Array.Empty<string>();
+        if (missing.Count > 0)
+        {
+            throw new InvalidOperationException(
+                $"Engine '{descriptor.ModuleKey}/{descriptor.Manifest.Id}' is missing required services: {string.Join(", ", missing)}.");
+        }
+    }
+}
diff --git a/tests/Bravellian.Platform.Tests/EngineRefactoringTests.cs b/tests/Bravellian.Platform.Tests/EngineRefactoringTests.cs
new file mode 100644
index 00000000..8d406938
--- /dev/null
+++ b/tests/Bravellian.Platform.Tests/EngineRefactoringTests.cs
@@ -0,0 +1,356 @@
+// Copyright (c) Bravellian
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using Bravellian.Platform.Modularity;
+using Microsoft.AspNetCore.Mvc.RazorPages;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Xunit;
+
+namespace Bravellian.Platform.Tests;
+
+public sealed class EngineRefactoringTests
+{
+    public EngineRefactoringTests()
+    {
+        ModuleEngineRegistry.Reset();
+        FullStackModuleRegistry.RegisterFullStackModule<FakeEngineModule>();
+    }
+
+    [Fact]
+    public async Task Ui_engine_invocation_returns_view_model_and_navigation_tokens()
+    {
+        var provider = BuildServiceProvider();
+        var adapter = new UiEngineAdapter(provider.GetRequiredService<ModuleEngineDiscoveryService>(), provider);
+
+        var response = await adapter.ExecuteAsync<LoginCommand, LoginViewModel>("fake-module", "ui.login", new LoginCommand("admin", "pass"), CancellationToken.None);
+
+        Assert.Equal("admin", response.ViewModel.Username);
+        Assert.Contains(response.NavigationTargets!, token => token.Token == "dashboard" && token.TargetKind == NavigationTargetKind.Route);
+        Assert.Contains("event:login", response.Events);
+    }
+
+    [Fact]
+    public async Task Webhook_adapter_enforces_signature_and_maps_outcome()
+    {
+        var provider = BuildServiceProvider();
+        var adapter = new WebhookEngineAdapter(provider.GetRequiredService<ModuleEngineDiscoveryService>(), provider, provider.GetRequiredService<IWebhookSignatureValidator>());
+
+        var request = new WebhookAdapterRequest<PostmarkBouncePayload>(
+            "postmark",
+            "bounce",
+            new Dictionary<string, string> { ["X-Signature"] = "postmark:raw-body" },
+            "raw-body",
+            "idemp-1",
+            1,
+            null,
+            new PostmarkBouncePayload("HardBounce", "Mail rejected"));
+
+        var response = await adapter.DispatchAsync(request, CancellationToken.None);
+
+        Assert.Equal(WebhookOutcomeType.EnqueueEvent, response.Outcome);
+    }
+
+    [Fact]
+    public async Task Webhook_adapter_rejects_invalid_signature()
+    {
+        var provider = BuildServiceProvider();
+        var adapter = new WebhookEngineAdapter(provider.GetRequiredService<ModuleEngineDiscoveryService>(), provider, provider.GetRequiredService<IWebhookSignatureValidator>());
+
+        var request = new WebhookAdapterRequest<PostmarkBouncePayload>(
+            "postmark",
+            "bounce",
+            new Dictionary<string, string> { ["X-Signature"] = "invalid-signature" },
+            "raw-body",
+            "idemp-1",
+            1,
+            null,
+            new PostmarkBouncePayload("HardBounce", "Mail rejected"));
+
+        var response = await adapter.DispatchAsync(request, CancellationToken.None);
+
+        Assert.Equal(WebhookOutcomeType.Acknowledge, response.Outcome);
+        Assert.Contains("Signature validation failed", response.Reason);
+    }
+
+    [Theory]
+    [InlineData("")]
+    [InlineData("   ")]
+    public async Task Webhook_adapter_requires_idempotency_key_when_configured(string idempotencyKey)
+    {
+        var provider = BuildServiceProvider();
+        var adapter = new WebhookEngineAdapter(provider.GetRequiredService<ModuleEngineDiscoveryService>(), provider, provider.GetRequiredService<IWebhookSignatureValidator>());
+
+        var request = new WebhookAdapterRequest<PostmarkBouncePayload>(
+            "postmark",
+            "bounce",
+            new Dictionary<string, string> { ["X-Signature"] = "postmark:raw-body" },
+            "raw-body",
+            idempotencyKey,
+            1,
+            null,
+            new PostmarkBouncePayload("HardBounce", "Mail rejected"));
+
+        var response = await adapter.DispatchAsync(request, CancellationToken.None);
+
+        Assert.Equal(WebhookOutcomeType.Retry, response.Outcome);
+        Assert.Contains("Idempotency key is required", response.Reason);
+    }
+
+    [Fact]
+    public async Task Webhook_adapter_throws_when_engine_is_not_registered()
+    {
+        var provider = BuildServiceProvider();
+        var adapter = new WebhookEngineAdapter(provider.GetRequiredService<ModuleEngineDiscoveryService>(), provider, provider.GetRequiredService<IWebhookSignatureValidator>());
+
+        var request = new WebhookAdapterRequest<PostmarkBouncePayload>(
+            "missing",
+            "event",
+            new Dictionary<string, string> { ["X-Signature"] = "missing:raw-body" },
+            "raw-body",
+            "idemp-1",
+            1,
+            null,
+            new PostmarkBouncePayload("HardBounce", "Mail rejected"));
+
+        var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => adapter.DispatchAsync(request, CancellationToken.None));
+        Assert.Contains("No webhook engine registered", ex.Message);
+    }
+
+    [Fact]
+    public async Task Webhook_adapter_throws_when_engine_contract_is_mismatched()
+    {
+        var provider = BuildServiceProvider();
+        var adapter = new WebhookEngineAdapter(provider.GetRequiredService<ModuleEngineDiscoveryService>(), provider, provider.GetRequiredService<IWebhookSignatureValidator>());
+
+        var request = new WebhookAdapterRequest<OtherWebhookPayload>(
+            "postmark",
+            "bounce",
+            new Dictionary<string, string> { ["X-Signature"] = "postmark:raw-body" },
+            "raw-body",
+            "idemp-1",
+            1,
+            null,
+            new OtherWebhookPayload("wrong"));
+
+        var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => adapter.DispatchAsync(request, CancellationToken.None));
+        Assert.Contains("does not implement expected webhook contract", ex.Message);
+    }
+
+    [Fact]
+    public async Task Ui_engine_exception_propagates_to_adapter()
+    {
+        var provider = BuildServiceProvider();
+        var adapter = new UiEngineAdapter(provider.GetRequiredService<ModuleEngineDiscoveryService>(), provider);
+
+        await Assert.ThrowsAsync<ArgumentException>(async () =>
+            await adapter.ExecuteAsync<LoginCommand, LoginViewModel>("fake-module", "ui.login", new LoginCommand(string.Empty, "pass"), CancellationToken.None));
+    }
+
+    [Fact]
+    public async Task Ui_adapter_throws_when_engine_is_not_registered()
+    {
+        var provider = BuildServiceProvider();
+        var adapter = new UiEngineAdapter(provider.GetRequiredService<ModuleEngineDiscoveryService>(), provider);
+
+        var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () =>
+            await adapter.ExecuteAsync<LoginCommand, LoginViewModel>("fake-module", "ui.missing", new LoginCommand("admin", "pass"), CancellationToken.None));
+
+        Assert.Contains("No UI engine registered", ex.Message);
+    }
+
+    [Fact]
+    public async Task Ui_adapter_throws_when_engine_contract_is_mismatched()
+    {
+        var provider = BuildServiceProvider();
+        var adapter = new UiEngineAdapter(provider.GetRequiredService<ModuleEngineDiscoveryService>(), provider);
+
+        var ex = await Assert.ThrowsAsync<InvalidOperationException>(async () =>
+            await adapter.ExecuteAsync<LoginCommand, LoginViewModel>("fake-module", "webhook.postmark", new LoginCommand("admin", "pass"), CancellationToken.None));
+
+        Assert.Contains("does not implement the expected UI contract", ex.Message);
+    }
+
+    [Fact]
+    public void Discovery_service_filters_engines()
+    {
+        var provider = BuildServiceProvider();
+        var discovery = provider.GetRequiredService<ModuleEngineDiscoveryService>();
+
+        var allEngines = discovery.List();
+        Assert.Contains(allEngines, e => e.Manifest.Kind == EngineKind.Ui && e.ModuleKey == "fake-module");
+
+        var webhookEngines = discovery.List(EngineKind.Webhook, featureArea: "Notifications");
+        Assert.Contains(webhookEngines, e => e.Manifest.Id == "webhook.postmark" && e.ModuleKey == "fake-module");
+
+        var resolved = discovery.ResolveWebhookEngine("postmark", "bounce");
+        Assert.NotNull(resolved);
+        Assert.Equal("fake-module", resolved!.ModuleKey);
+    }
+
+    private static ServiceProvider BuildServiceProvider()
+    {
+        var services = new ServiceCollection();
+        services.AddSingleton<IWebhookSignatureValidator, TestSignatureValidator>();
+        services.AddSingleton<IRequiredServiceValidator, TestRequiredServiceValidator>();
+        services.AddFullStackModuleServices(new ConfigurationBuilder().Build());
+        services.AddSingleton<UiEngineAdapter>();
+        services.AddSingleton<WebhookEngineAdapter>();
+        return services.BuildServiceProvider();
+    }
+
+    private sealed class FakeEngineModule : IFullStackModule, INavigationModuleMetadata, IEngineModule
+    {
+        public string Key => "fake-module";
+
+        public string DisplayName => "Fake Engines";
+
+        public string AreaName => "Fake";
+
+        public string NavigationGroup => "Engines";
+
+        public int NavigationOrder => 0;
+
+        public IEnumerable<string> GetOptionalConfigurationKeys() => Array.Empty<string>();
+
+        public IEnumerable<string> GetRequiredConfigurationKeys() => Array.Empty<string>();
+
+        public void LoadConfiguration(IReadOnlyDictionary<string, string> required, IReadOnlyDictionary<string, string> optional)
+        {
+        }
+
+        public void AddModuleServices(IServiceCollection services)
+        {
+            services.AddSingleton<LoginUiEngine>();
+            services.AddSingleton<PostmarkWebhookEngine>();
+        }
+
+        public void RegisterHealthChecks(ModuleHealthCheckBuilder builder)
+        {
+        }
+
+        public IEnumerable<ModuleNavLink> GetNavLinks()
+        {
+            yield return ModuleNavLink.Create("Home", "/", 0, null);
+        }
+
+        public void ConfigureRazorPages(RazorPagesOptions options)
+        {
+        }
+
+        public void MapApiEndpoints(Microsoft.AspNetCore.Routing.RouteGroupBuilder group)
+        {
+        }
+
+        public IEnumerable<IModuleEngineDescriptor> DescribeEngines()
+        {
+            yield return new ModuleEngineDescriptor<IUiEngine<LoginCommand, LoginViewModel>>(
+                Key,
+                new ModuleEngineManifest(
+                    "ui.login",
+                    "1.0",
+                    "Login page engine",
+                    EngineKind.Ui,
+                    "Auth",
+                    new ModuleEngineCapabilities(new[] { "login" }, new[] { "login.loggedIn" }, SupportsStreaming: false),
+                    new[] { new ModuleEngineSchema("command", typeof(LoginCommand)) },
+                    new[] { new ModuleEngineSchema("viewModel", typeof(LoginViewModel)) },
+                    new ModuleEngineNavigationHints(new[] { new ModuleNavigationToken("dashboard", NavigationTargetKind.Route) }),
+                    new[] { nameof(LoginUiEngine) },
+                    new ModuleEngineAdapterHints(false, false, false, false, true),
+                    null,
+                    new ModuleEngineCompatibility("1.0", null)),
+                sp => sp.GetRequiredService<LoginUiEngine>());
+
+            yield return new ModuleEngineDescriptor<IWebhookEngine<PostmarkBouncePayload>>(
+                Key,
+                new ModuleEngineManifest(
+                    "webhook.postmark",
+                    "1.0",
+                    "Postmark bounce webhook handler",
+                    EngineKind.Webhook,
+                    "Notifications",
+                    new ModuleEngineCapabilities(new[] { "handle" }, new[] { "bounce.received" }, SupportsStreaming: false),
+                    new[] { new ModuleEngineSchema("payload", typeof(PostmarkBouncePayload)) },
+                    Array.Empty<ModuleEngineSchema>(),
+                    null,
+                    new[] { nameof(PostmarkWebhookEngine) },
+                    new ModuleEngineAdapterHints(true, true, true, false, true),
+                    new ModuleEngineSecurity(ModuleSignatureAlgorithm.HmacSha256, "postmark", TimeSpan.FromMinutes(10)),
+                    new ModuleEngineCompatibility("1.0", "Initial"),
+                    new[]
+                    {
+                        new ModuleEngineWebhookMetadata("postmark", "bounce", new ModuleEngineSchema("payload", typeof(PostmarkBouncePayload)), new[] { "logging" }, Retries: 3),
+                    }),
+                sp => sp.GetRequiredService<PostmarkWebhookEngine>());
+        }
+    }
+
+    private sealed record LoginCommand(string Username, string Password);
+
+    private sealed record LoginViewModel(string Username, bool Success);
+
+    private sealed class LoginUiEngine : IUiEngine<LoginCommand, LoginViewModel>
+    {
+        public Task<UiEngineResult<LoginViewModel>> ExecuteAsync(LoginCommand command, CancellationToken cancellationToken)
+        {
+            if (string.IsNullOrWhiteSpace(command.Username))
+            {
+                throw new ArgumentException("Username is required", nameof(command));
+            }
+
+            var viewModel = new LoginViewModel(command.Username, true);
+            return Task.FromResult(new UiEngineResult<LoginViewModel>(
+                viewModel,
+                new[] { new ModuleNavigationToken("dashboard", NavigationTargetKind.Route) },
+                new[] { "event:login" }));
+        }
+    }
+
+    private sealed record PostmarkBouncePayload(string Type, string Description);
+
+    private sealed record OtherWebhookPayload(string Value);
+
+    private sealed class PostmarkWebhookEngine : IWebhookEngine<PostmarkBouncePayload>
+    {
+        public Task<WebhookOutcome> HandleAsync(WebhookRequest<PostmarkBouncePayload> request, CancellationToken cancellationToken)
+        {
+            if (request.Payload.Type.Equals("HardBounce", StringComparison.OrdinalIgnoreCase))
+            {
+                return Task.FromResult(WebhookOutcome.Enqueue(new { request.Payload.Description, request.EventType }));
+            }
+
+            return Task.FromResult(WebhookOutcome.Acknowledge());
+        }
+    }
+
+    private sealed class TestSignatureValidator : IWebhookSignatureValidator
+    {
+        public bool Validate(ModuleEngineSecurity security, IReadOnlyDictionary<string, string> headers, string rawBody, string? providedSignature)
+        {
+            headers.TryGetValue("X-Signature", out var headerSignature);
+            var signature = providedSignature ?? headerSignature;
+            return security.SignatureAlgorithm == ModuleSignatureAlgorithm.HmacSha256
+                && signature == $"{security.SecretScope}:{rawBody}";
+        }
+    }
+
+    private sealed class TestRequiredServiceValidator : IRequiredServiceValidator
+    {
+        public IReadOnlyCollection<string> GetMissingServices(IReadOnlyCollection<string> requiredServices)
+        {
+            return Array.Empty<string>();
+        }
+    }
+}
diff --git a/tests/Bravellian.Platform.Tests/Modularity/ModuleSystemTests.cs b/tests/Bravellian.Platform.Tests/Modularity/ModuleSystemTests.cs
index 47eebf91..345e4311 100644
--- a/tests/Bravellian.Platform.Tests/Modularity/ModuleSystemTests.cs
+++ b/tests/Bravellian.Platform.Tests/Modularity/ModuleSystemTests.cs
@@ -146,6 +146,37 @@ public void Module_keys_with_slashes_are_rejected()
         ex.Message.ShouldContain("cannot contain slashes");
     }
 
+    [Fact]
+    public void Engine_descriptor_module_key_must_match_module_key()
+    {
+        BackgroundModuleRegistry.Reset();
+        ApiModuleRegistry.RegisterApiModule<ModuleWithMismatchedEngineDescriptor>();
+
+        var configuration = new ConfigurationBuilder().Build();
+        var services = new ServiceCollection();
+
+        var ex = Should.Throw<InvalidOperationException>(() => services.AddApiModuleServices(configuration, NullLoggerFactory.Instance));
+        ex.Message.ShouldContain("Engine descriptor module key");
+        ex.Message.ShouldContain("module-alpha");
+        ex.Message.ShouldContain("module-beta");
+    }
+
+    [Fact]
+    public void Duplicate_webhook_provider_event_pairs_are_rejected()
+    {
+        BackgroundModuleRegistry.Reset();
+        ApiModuleRegistry.RegisterApiModule<WebhookModuleOne>();
+        ApiModuleRegistry.RegisterApiModule<WebhookModuleTwo>();
+
+        var configuration = new ConfigurationBuilder().Build();
+        var services = new ServiceCollection();
+
+        var ex = Should.Throw<InvalidOperationException>(() => services.AddApiModuleServices(configuration, NullLoggerFactory.Instance));
+        ex.Message.ShouldContain("postmark");
+        ex.Message.ShouldContain("bounce");
+        ex.Message.ShouldContain("already handled");
+    }
+
     [Fact]
     public void Duplicate_module_type_registrations_in_same_category_are_idempotent()
     {
@@ -235,6 +266,169 @@ public void MapApiEndpoints(RouteGroupBuilder group)
         }
     }
 
+    private sealed class ModuleWithMismatchedEngineDescriptor : IApiModule, IEngineModule
+    {
+        public string Key => "module-alpha";
+
+        public string DisplayName => "Module With Mismatched Descriptor";
+
+        public IEnumerable<string> GetRequiredConfigurationKeys() => Array.Empty<string>();
+
+        public IEnumerable<string> GetOptionalConfigurationKeys() => Array.Empty<string>();
+
+        public void LoadConfiguration(IReadOnlyDictionary<string, string> required, IReadOnlyDictionary<string, string> optional)
+        {
+        }
+
+        public void AddModuleServices(IServiceCollection services)
+        {
+        }
+
+        public void RegisterHealthChecks(ModuleHealthCheckBuilder builder)
+        {
+        }
+
+        public void MapApiEndpoints(RouteGroupBuilder group)
+        {
+        }
+
+        public IEnumerable<IModuleEngineDescriptor> DescribeEngines()
+        {
+            yield return new ModuleEngineDescriptor<IUiEngine<DummyCommand, DummyViewModel>>(
+                "module-beta",
+                new ModuleEngineManifest(
+                    "ui.dummy",
+                    "1.0",
+                    "Dummy UI engine",
+                    EngineKind.Ui),
+                _ => new DummyUiEngine());
+        }
+    }
+
+    private sealed record DummyCommand;
+
+    private sealed record DummyViewModel;
+
+    private sealed class DummyUiEngine : IUiEngine<DummyCommand, DummyViewModel>
+    {
+        public Task<UiEngineResult<DummyViewModel>> ExecuteAsync(DummyCommand command, CancellationToken cancellationToken)
+        {
+            return Task.FromResult(new UiEngineResult<DummyViewModel>(new DummyViewModel()));
+        }
+    }
+
+    private sealed class WebhookModuleOne : IApiModule, IEngineModule
+    {
+        public string Key => "webhook-module-one";
+
+        public string DisplayName => "Webhook Module One";
+
+        public IEnumerable<string> GetRequiredConfigurationKeys() => Array.Empty<string>();
+
+        public IEnumerable<string> GetOptionalConfigurationKeys() => Array.Empty<string>();
+
+        public void LoadConfiguration(IReadOnlyDictionary<string, string> required, IReadOnlyDictionary<string, string> optional)
+        {
+        }
+
+        public void AddModuleServices(IServiceCollection services)
+        {
+            services.AddSingleton<WebhookEngineOne>();
+        }
+
+        public void RegisterHealthChecks(ModuleHealthCheckBuilder builder)
+        {
+        }
+
+        public void MapApiEndpoints(RouteGroupBuilder group)
+        {
+        }
+
+        public IEnumerable<IModuleEngineDescriptor> DescribeEngines()
+        {
+            yield return new ModuleEngineDescriptor<IWebhookEngine<DummyWebhookPayload>>(
+                Key,
+                new ModuleEngineManifest(
+                    "webhook.one",
+                    "1.0",
+                    "Webhook engine one",
+                    EngineKind.Webhook,
+                    WebhookMetadata: new[]
+                    {
+                        new ModuleEngineWebhookMetadata(
+                            "postmark",
+                            "bounce",
+                            new ModuleEngineSchema("payload", typeof(DummyWebhookPayload))),
+                    }),
+                sp => sp.GetRequiredService<WebhookEngineOne>());
+        }
+    }
+
+    private sealed class WebhookModuleTwo : IApiModule, IEngineModule
+    {
+        public string Key => "webhook-module-two";
+
+        public string DisplayName => "Webhook Module Two";
+
+        public IEnumerable<string> GetRequiredConfigurationKeys() => Array.Empty<string>();
+
+        public IEnumerable<string> GetOptionalConfigurationKeys() => Array.Empty<string>();
+
+        public void LoadConfiguration(IReadOnlyDictionary<string, string> required, IReadOnlyDictionary<string, string> optional)
+        {
+        }
+
+        public void AddModuleServices(IServiceCollection services)
+        {
+            services.AddSingleton<WebhookEngineTwo>();
+        }
+
+        public void RegisterHealthChecks(ModuleHealthCheckBuilder builder)
+        {
+        }
+
+        public void MapApiEndpoints(RouteGroupBuilder group)
+        {
+        }
+
+        public IEnumerable<IModuleEngineDescriptor> DescribeEngines()
+        {
+            yield return new ModuleEngineDescriptor<IWebhookEngine<DummyWebhookPayload>>(
+                Key,
+                new ModuleEngineManifest(
+                    "webhook.two",
+                    "1.0",
+                    "Webhook engine two",
+                    EngineKind.Webhook,
+                    WebhookMetadata: new[]
+                    {
+                        new ModuleEngineWebhookMetadata(
+                            "postmark",
+                            "bounce",
+                            new ModuleEngineSchema("payload", typeof(DummyWebhookPayload))),
+                    }),
+                sp => sp.GetRequiredService<WebhookEngineTwo>());
+        }
+    }
+
+    private sealed record DummyWebhookPayload(string Id);
+
+    private sealed class WebhookEngineOne : IWebhookEngine<DummyWebhookPayload>
+    {
+        public Task<WebhookOutcome> HandleAsync(WebhookRequest<DummyWebhookPayload> request, CancellationToken cancellationToken)
+        {
+            return Task.FromResult(WebhookOutcome.Acknowledge());
+        }
+    }
+
+    private sealed class WebhookEngineTwo : IWebhookEngine<DummyWebhookPayload>
+    {
+        public Task<WebhookOutcome> HandleAsync(WebhookRequest<DummyWebhookPayload> request, CancellationToken cancellationToken)
+        {
+            return Task.FromResult(WebhookOutcome.Acknowledge());
+        }
+    }
+
     private sealed class SampleFullStackModule : IFullStackModule, INavigationModuleMetadata
     {
         internal const string RequiredKey = "fullstack:required";
diff --git a/tests/Bravellian.Platform.Tests/Modularity/RequiredServiceValidationTests.cs b/tests/Bravellian.Platform.Tests/Modularity/RequiredServiceValidationTests.cs
new file mode 100644
index 00000000..4d0576bd
--- /dev/null
+++ b/tests/Bravellian.Platform.Tests/Modularity/RequiredServiceValidationTests.cs
@@ -0,0 +1,192 @@
+// Copyright (c) Bravellian
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using Bravellian.Platform.Modularity;
+using Microsoft.AspNetCore.Routing;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging.Abstractions;
+using Shouldly;
+
+namespace Bravellian.Platform.Tests.Modularity;
+
+[Collection("ModuleRegistryTests")]
+public sealed class RequiredServiceValidationTests
+{
+    [Fact]
+    public async Task Ui_adapter_requires_required_service_validator_when_engine_declares_required_services()
+    {
+        ModuleRegistry.Reset();
+        ApiModuleRegistry.RegisterApiModule<RequiredServiceModule>();
+
+        var services = new ServiceCollection();
+        services.AddApiModuleServices(new ConfigurationBuilder().Build(), NullLoggerFactory.Instance);
+
+        using var provider = services.BuildServiceProvider();
+        var adapter = new UiEngineAdapter(provider.GetRequiredService<ModuleEngineDiscoveryService>(), provider);
+
+        var ex = await Should.ThrowAsync<InvalidOperationException>(async () =>
+            await adapter.ExecuteAsync<DummyCommand, DummyViewModel>(
+                "required-service-module",
+                "ui.required",
+                new DummyCommand(),
+                CancellationToken.None));
+
+        ex.Message.ShouldContain(nameof(IRequiredServiceValidator));
+    }
+
+    [Fact]
+    public async Task Ui_adapter_throws_when_required_services_are_missing()
+    {
+        ModuleRegistry.Reset();
+        ApiModuleRegistry.RegisterApiModule<RequiredServiceModule>();
+
+        var services = new ServiceCollection();
+        services.AddSingleton<IRequiredServiceValidator>(new TestRequiredServiceValidator(Array.Empty<string>()));
+        services.AddApiModuleServices(new ConfigurationBuilder().Build(), NullLoggerFactory.Instance);
+
+        using var provider = services.BuildServiceProvider();
+        var adapter = new UiEngineAdapter(provider.GetRequiredService<ModuleEngineDiscoveryService>(), provider);
+
+        var ex = await Should.ThrowAsync<InvalidOperationException>(async () =>
+            await adapter.ExecuteAsync<DummyCommand, DummyViewModel>(
+                "required-service-module",
+                "ui.required",
+                new DummyCommand(),
+                CancellationToken.None));
+
+        ex.Message.ShouldContain("missing required services");
+        ex.Message.ShouldContain("cache");
+    }
+
+    [Fact]
+    public async Task Ui_adapter_executes_when_required_services_are_satisfied()
+    {
+        ModuleRegistry.Reset();
+        ApiModuleRegistry.RegisterApiModule<RequiredServiceModule>();
+
+        var services = new ServiceCollection();
+        services.AddSingleton<IRequiredServiceValidator>(new TestRequiredServiceValidator(new[] { "cache", "telemetry" }));
+        services.AddApiModuleServices(new ConfigurationBuilder().Build(), NullLoggerFactory.Instance);
+
+        using var provider = services.BuildServiceProvider();
+        var adapter = new UiEngineAdapter(provider.GetRequiredService<ModuleEngineDiscoveryService>(), provider);
+
+        var response = await adapter.ExecuteAsync<DummyCommand, DummyViewModel>(
+            "required-service-module",
+            "ui.required",
+            new DummyCommand(),
+            CancellationToken.None);
+
+        response.ViewModel.Value.ShouldBe("ok");
+    }
+
+    [Fact]
+    public void Discovery_service_resolve_engine_throws_when_factory_returns_null()
+    {
+        var discovery = new ModuleEngineDiscoveryService();
+
+        var descriptor = new ModuleEngineDescriptor<IUiEngine<DummyCommand, DummyViewModel>>(
+            "null-module",
+            new ModuleEngineManifest(
+                "ui.null",
+                "1.0",
+                "Null engine factory",
+                EngineKind.Ui),
+            _ => null!);
+
+        var services = new ServiceCollection().BuildServiceProvider();
+
+        var ex = Should.Throw<InvalidOperationException>(() => discovery.ResolveEngine(descriptor, services));
+        ex.Message.ShouldContain("returned null");
+        ex.Message.ShouldContain("null-module/ui.null");
+    }
+
+    private sealed class RequiredServiceModule : IApiModule, IEngineModule
+    {
+        public string Key => "required-service-module";
+
+        public string DisplayName => "Required Service Module";
+
+        public IEnumerable<string> GetRequiredConfigurationKeys() => Array.Empty<string>();
+
+        public IEnumerable<string> GetOptionalConfigurationKeys() => Array.Empty<string>();
+
+        public void LoadConfiguration(IReadOnlyDictionary<string, string> required, IReadOnlyDictionary<string, string> optional)
+        {
+        }
+
+        public void AddModuleServices(IServiceCollection services)
+        {
+            services.AddSingleton<DummyUiEngine>();
+        }
+
+        public void RegisterHealthChecks(ModuleHealthCheckBuilder builder)
+        {
+        }
+
+        public void MapApiEndpoints(RouteGroupBuilder group)
+        {
+        }
+
+        public IEnumerable<IModuleEngineDescriptor> DescribeEngines()
+        {
+            yield return new ModuleEngineDescriptor<IUiEngine<DummyCommand, DummyViewModel>>(
+                Key,
+                new ModuleEngineManifest(
+                    "ui.required",
+                    "1.0",
+                    "Engine that requires host services",
+                    EngineKind.Ui,
+                    RequiredServices: new[] { "cache", "telemetry" }),
+                sp => sp.GetRequiredService<DummyUiEngine>());
+        }
+    }
+
+    private sealed record DummyCommand;
+
+    private sealed record DummyViewModel(string Value);
+
+    private sealed class DummyUiEngine : IUiEngine<DummyCommand, DummyViewModel>
+    {
+        public Task<UiEngineResult<DummyViewModel>> ExecuteAsync(DummyCommand command, CancellationToken cancellationToken)
+        {
+            return Task.FromResult(new UiEngineResult<DummyViewModel>(new DummyViewModel("ok")));
+        }
+    }
+
+    private sealed class TestRequiredServiceValidator : IRequiredServiceValidator
+    {
+        private readonly HashSet<string> available;
+
+        public TestRequiredServiceValidator(IEnumerable<string> available)
+        {
+            this.available = new HashSet<string>(available, StringComparer.OrdinalIgnoreCase);
+        }
+
+        public IReadOnlyCollection<string> GetMissingServices(IReadOnlyCollection<string> requiredServices)
+        {
+            var missing = new List<string>();
+            foreach (var service in requiredServices)
+            {
+                if (!available.Contains(service))
+                {
+                    missing.Add(service);
+                }
+            }
+
+            return missing;
+        }
+    }
+}