diff --git a/src/Http/Wolverine.Http.Marten/AggregateAttribute.cs b/src/Http/Wolverine.Http.Marten/AggregateAttribute.cs
index 0df7bce95..f46cb6ded 100644
--- a/src/Http/Wolverine.Http.Marten/AggregateAttribute.cs
+++ b/src/Http/Wolverine.Http.Marten/AggregateAttribute.cs
@@ -54,7 +54,7 @@ public AggregateAttribute(string routeOrParameterName)
 
     public override Variable Modify(HttpChain chain, ParameterInfo parameter, IServiceContainer container)
     {
-        if (chain.Method.Method.GetParameters().Where(x => x.HasAttribute<AggregateAttribute>()).Count() > 1)
+        if (chain.Method.Method.GetParameters().Count(x => x.HasAttribute<AggregateAttribute>()) > 1)
         {
             throw new InvalidOperationException(
                 "It is only possible (today) to use a single [Aggregate] attribute on an HTTP handler method. Maybe use [ReadAggregate] if all you need is the projected data");
@@ -63,8 +63,13 @@ public override Variable Modify(HttpChain chain, ParameterInfo parameter, IServi
         chain.Metadata.Produces(404);
 
         AggregateType = parameter.ParameterType;
+        if (AggregateType.IsNullable())
+        {
+            AggregateType = AggregateType.GetInnerTypeFromNullable();
+        }
+        
         var store = container.GetInstance<IDocumentStore>();
-        var idType = store.Options.Events.StreamIdentity == StreamIdentity.AsGuid ? typeof(Guid) : typeof(string);
+        var idType = store.Options.FindOrResolveDocumentType(AggregateType).IdType;
 
         IdVariable = FindRouteVariable(idType, chain);
         if (IdVariable == null)
diff --git a/src/Persistence/MartenTests/AggregateHandlerAttributeTests.cs b/src/Persistence/MartenTests/AggregateHandlerWorkflow/AggregateHandlerAttributeTests.cs
similarity index 98%
rename from src/Persistence/MartenTests/AggregateHandlerAttributeTests.cs
rename to src/Persistence/MartenTests/AggregateHandlerWorkflow/AggregateHandlerAttributeTests.cs
index 7860f4619..0b8dc6291 100644
--- a/src/Persistence/MartenTests/AggregateHandlerAttributeTests.cs
+++ b/src/Persistence/MartenTests/AggregateHandlerWorkflow/AggregateHandlerAttributeTests.cs
@@ -1,14 +1,13 @@
 using JasperFx.CodeGeneration;
 using Marten.Schema;
 using NSubstitute;
+using Shouldly;
 using Wolverine.Configuration;
 using Wolverine.Marten;
-using Wolverine.Runtime.Handlers;
-using Shouldly;
-using Wolverine.Codegen;
 using Wolverine.Runtime;
+using Wolverine.Runtime.Handlers;
 
-namespace MartenTests;
+namespace MartenTests.AggregateHandlerWorkflow;
 
 public class AggregateHandlerAttributeTests
 {
diff --git a/src/Persistence/MartenTests/aggregate_handler_workflow.cs b/src/Persistence/MartenTests/AggregateHandlerWorkflow/aggregate_handler_workflow.cs
similarity index 99%
rename from src/Persistence/MartenTests/aggregate_handler_workflow.cs
rename to src/Persistence/MartenTests/AggregateHandlerWorkflow/aggregate_handler_workflow.cs
index f671281ea..3e69682e2 100644
--- a/src/Persistence/MartenTests/aggregate_handler_workflow.cs
+++ b/src/Persistence/MartenTests/AggregateHandlerWorkflow/aggregate_handler_workflow.cs
@@ -3,18 +3,18 @@
 using JasperFx.CodeGeneration;
 using JasperFx.Core;
 using JasperFx.Events;
+using JasperFx.Resources;
 using Marten;
 using Marten.Events;
 using Marten.Events.Projections;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
-using JasperFx.Resources;
 using Shouldly;
 using Wolverine;
 using Wolverine.Marten;
 using Wolverine.Tracking;
 
-namespace MartenTests;
+namespace MartenTests.AggregateHandlerWorkflow;
 
 public class aggregate_handler_workflow: PostgresqlContext, IAsyncLifetime
 {
@@ -440,4 +440,5 @@ public static Response For(LetterAggregate aggregate)
     public int BCount { get; set; }
     public int CCount { get; set; }
     public int DCount { get; set; }
-}
\ No newline at end of file
+}
+
diff --git a/src/Persistence/MartenTests/AggregateHandlerWorkflow/aggregate_handler_workflow_with_ievent.cs b/src/Persistence/MartenTests/AggregateHandlerWorkflow/aggregate_handler_workflow_with_ievent.cs
new file mode 100644
index 000000000..1c5930508
--- /dev/null
+++ b/src/Persistence/MartenTests/AggregateHandlerWorkflow/aggregate_handler_workflow_with_ievent.cs
@@ -0,0 +1,184 @@
+using IntegrationTests;
+using JasperFx;
+using JasperFx.CodeGeneration;
+using JasperFx.Core.Reflection;
+using JasperFx.Events;
+using JasperFx.Events.Projections;
+using JasperFx.Resources;
+using Marten;
+using Marten.Events.Aggregation;
+using Marten.Events.Projections;
+using Microsoft.Extensions.Hosting;
+using Shouldly;
+using Wolverine;
+using Wolverine.Marten;
+using Wolverine.Runtime;
+using Wolverine.Tracking;
+using Xunit.Abstractions;
+
+namespace MartenTests.AggregateHandlerWorkflow;
+
+public class aggregate_handler_workflow_with_ievent
+{
+    private readonly ITestOutputHelper _output;
+
+    public aggregate_handler_workflow_with_ievent(ITestOutputHelper output)
+    {
+        _output = output;
+    }
+
+    [Fact]
+    public async Task use_ievent_as_Guid_id()
+    {
+        using var host = await Host.CreateDefaultBuilder()
+            .UseWolverine(opts =>
+            {
+                opts.Discovery.DisableConventionalDiscovery().IncludeType(typeof(AEventHandler)).IncludeType(typeof(RaiseLetterHandler));
+                
+                opts.Services.AddMarten(m =>
+                    {
+                        m.Connection(Servers.PostgresConnectionString);
+                        m.Projections.Snapshot<LetterAggregate>(SnapshotLifecycle.Inline);
+
+                        m.DisableNpgsqlLogging = true;
+                    })
+                    .UseLightweightSessions()
+                    .IntegrateWithWolverine(x =>
+                    {
+                        x.UseFastEventForwarding = true;
+                    });
+                
+                opts.Policies.AutoApplyTransactions();
+                
+
+                opts.Services.AddResourceSetupOnStartup();
+            }).StartAsync();
+
+        var store = host.DocumentStore();
+        using var session = store.LightweightSession();
+        
+        var streamId = Guid.NewGuid();
+
+        session.Events.StartStream<LetterAggregate>(streamId, new AEvent(), new BEvent());
+        await session.SaveChangesAsync();
+
+        var tracked = await host.InvokeMessageAndWaitAsync(new RaiseABC(streamId));
+
+        tracked.Executed.SingleEnvelope<IEvent<AEvent>>().ShouldNotBeNull();
+
+        var doc = await session.LoadAsync<LetterAggregate>(streamId);
+        doc.DCount.ShouldBe(1);
+    }
+
+    [Fact]
+    public async Task using_string_as_stream_key()
+    {
+        using var host = await Host.CreateDefaultBuilder()
+            .UseWolverine(opts =>
+            {
+                opts.Discovery.DisableConventionalDiscovery().IncludeType(typeof(StringIdentifiedHandler));
+                
+                opts.Services.AddMarten(m =>
+                    {
+                        m.Events.StreamIdentity = StreamIdentity.AsString;
+                        
+                        m.Connection(Servers.PostgresConnectionString);
+                        m.DatabaseSchemaName = "as_string";
+                        m.Projections.Add<LetterCountsByStringProjection>(ProjectionLifecycle.Inline);
+
+                        m.DisableNpgsqlLogging = true;
+                    })
+                    .UseLightweightSessions()
+                    .IntegrateWithWolverine(x =>
+                    {
+                        x.UseFastEventForwarding = true;
+                    });
+                
+                opts.Policies.AutoApplyTransactions();
+                
+
+                opts.Services.AddResourceSetupOnStartup();
+            }).StartAsync();
+
+        var store = host.DocumentStore();
+        using var session = store.LightweightSession();
+        
+        var streamKey = Guid.NewGuid().ToString();
+
+        var tracked = await host.InvokeMessageAndWaitAsync(new StartLetterCountsByString(streamKey));
+
+        tracked.Executed.SingleEnvelope<IEvent<AEvent>>().ShouldNotBeNull();
+
+        var doc = await session.LoadAsync<LetterCountsByString>(streamKey);
+        doc.DCount.ShouldBe(1);
+    }
+    
+
+}
+
+public static class AEventHandler
+{
+    
+    
+    [AggregateHandler]
+    public static DEvent Handle(IEvent<AEvent> _, LetterAggregate aggregate)
+    {
+        return new DEvent();
+    }
+}
+
+public class LetterCountsByString: IRevisioned
+{
+    public string Id { get; set; }
+    public int ACount { get; set; }
+    public int BCount { get; set; }
+    public int CCount { get; set; }
+    public int DCount { get; set; }
+    public int Version { get; set; }
+}
+
+public record StartLetterCountsByString(string StreamKey);
+
+public static class StringIdentifiedHandler
+{
+    public static IStartStream Handle(StartLetterCountsByString command)
+    {
+        return MartenOps.StartStream<LetterCountsByString>(command.StreamKey, new AEvent(), new BEvent(), new CEvent());
+    }
+
+    [AggregateHandler]
+    public static DEvent Handle(IEvent<AEvent> e, LetterCountsByString aggregate)
+    {
+        aggregate.Id.ShouldBe(e.StreamKey);
+        return new DEvent();
+    }
+}
+
+public class LetterCountsByStringProjection: SingleStreamProjection<LetterCountsByString, string>
+{
+    public override LetterCountsByString Evolve(LetterCountsByString snapshot, string id, IEvent e)
+    {
+        snapshot ??= new LetterCountsByString { Id = id };
+
+        switch (e.Data)
+        {
+            case AEvent _:
+                snapshot.ACount++;
+                break;
+
+            case BEvent _:
+                snapshot.BCount++;
+                break;
+
+            case CEvent _:
+                snapshot.CCount++;
+                break;
+
+            case DEvent _:
+                snapshot.DCount++;
+                break;
+        }
+
+        return snapshot;
+    }
+}
diff --git a/src/Persistence/MartenTests/marten_command_workflow_middleware.cs b/src/Persistence/MartenTests/AggregateHandlerWorkflow/marten_command_workflow_middleware.cs
similarity index 99%
rename from src/Persistence/MartenTests/marten_command_workflow_middleware.cs
rename to src/Persistence/MartenTests/AggregateHandlerWorkflow/marten_command_workflow_middleware.cs
index 92175c1f8..55667252c 100644
--- a/src/Persistence/MartenTests/marten_command_workflow_middleware.cs
+++ b/src/Persistence/MartenTests/AggregateHandlerWorkflow/marten_command_workflow_middleware.cs
@@ -1,22 +1,21 @@
 using IntegrationTests;
 using JasperFx;
 using JasperFx.CodeGeneration;
+using JasperFx.Resources;
 using Marten;
 using Marten.Events;
 using Marten.Events.Projections;
-using Marten.Exceptions;
 using Marten.Internal.Sessions;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
-using JasperFx.Resources;
 using Shouldly;
-using Wolverine.ComplianceTests;
 using Wolverine.Attributes;
+using Wolverine.ComplianceTests;
 using Wolverine.Marten;
 using Wolverine.Tracking;
 
-namespace MartenTests;
+namespace MartenTests.AggregateHandlerWorkflow;
 
 public class marten_command_workflow_middleware : PostgresqlContext, IDisposable
 {
diff --git a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/Event3Handler1609469393.cs b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/Event3Handler1609469393.cs
index 9dd8ef29b..90d61d153 100644
--- a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/Event3Handler1609469393.cs
+++ b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/Event3Handler1609469393.cs
@@ -1,5 +1,6 @@
 // <auto-generated/>
 #pragma warning disable
+using MartenTests.AggregateHandlerWorkflow;
 using Wolverine.Marten.Publishing;
 
 namespace Internal.Generated.WolverineHandlers
@@ -19,18 +20,18 @@ public Event3Handler1609469393(Wolverine.Marten.Publishing.OutboxedSessionFactor
         public override async System.Threading.Tasks.Task HandleAsync(Wolverine.Runtime.MessageContext context, System.Threading.CancellationToken cancellation)
         {
             // The actual message body
-            var event3 = (MartenTests.Event3)context.Envelope.Message;
+            var event3 = (Event3)context.Envelope.Message;
 
             await using var documentSession = _outboxedSessionFactory.OpenSession(context);
             var eventStore = documentSession.Events;
             var aggregateId = event3.AggregateId;
             
             // Loading Marten aggregate
-            var eventStream = await eventStore.FetchForWriting<MartenTests.Aggregate>(aggregateId, cancellation).ConfigureAwait(false);
+            var eventStream = await eventStore.FetchForWriting<Aggregate>(aggregateId, cancellation).ConfigureAwait(false);
 
             
             // The actual message execution
-            var outgoing1 = MartenTests.FooHandler.Handle(event3, eventStream.Aggregate);
+            var outgoing1 = FooHandler.Handle(event3, eventStream.Aggregate);
 
             
             // Outgoing, cascaded message
diff --git a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementABHandler79726094.cs b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementABHandler79726094.cs
index b9931281d..d8e5c2829 100644
--- a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementABHandler79726094.cs
+++ b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementABHandler79726094.cs
@@ -1,5 +1,6 @@
 // <auto-generated/>
 #pragma warning disable
+using MartenTests.AggregateHandlerWorkflow;
 using Wolverine.Marten.Publishing;
 
 namespace Internal.Generated.WolverineHandlers
@@ -19,18 +20,18 @@ public IncrementABHandler79726094(Wolverine.Marten.Publishing.OutboxedSessionFac
         public override async System.Threading.Tasks.Task HandleAsync(Wolverine.Runtime.MessageContext context, System.Threading.CancellationToken cancellation)
         {
             // The actual message body
-            var incrementAB = (MartenTests.IncrementAB)context.Envelope.Message;
+            var incrementAB = (IncrementAB)context.Envelope.Message;
 
             await using var documentSession = _outboxedSessionFactory.OpenSession(context);
             var eventStore = documentSession.Events;
             var aggregateId = incrementAB.LetterAggregateId;
             
             // Loading Marten aggregate
-            var eventStream = await eventStore.FetchForExclusiveWriting<MartenTests.LetterAggregate>(aggregateId, cancellation).ConfigureAwait(false);
+            var eventStream = await eventStore.FetchForExclusiveWriting<LetterAggregate>(aggregateId, cancellation).ConfigureAwait(false);
 
             
             // The actual message execution
-            var outgoing1 = MartenTests.SpecialLetterHandler.Handle(incrementAB, eventStream.Aggregate);
+            var outgoing1 = SpecialLetterHandler.Handle(incrementAB, eventStream.Aggregate);
 
             if (outgoing1 != null)
             {
diff --git a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementAHandler1658474384.cs b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementAHandler1658474384.cs
index 67d7b91c3..92aa8accf 100644
--- a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementAHandler1658474384.cs
+++ b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementAHandler1658474384.cs
@@ -1,5 +1,6 @@
 // <auto-generated/>
 #pragma warning disable
+using MartenTests.AggregateHandlerWorkflow;
 using Wolverine.Marten.Publishing;
 
 namespace Internal.Generated.WolverineHandlers
@@ -19,16 +20,16 @@ public IncrementAHandler1658474384(Wolverine.Marten.Publishing.OutboxedSessionFa
         public override async System.Threading.Tasks.Task HandleAsync(Wolverine.Runtime.MessageContext context, System.Threading.CancellationToken cancellation)
         {
             // The actual message body
-            var incrementA = (MartenTests.IncrementA)context.Envelope.Message;
+            var incrementA = (IncrementA)context.Envelope.Message;
 
             await using var documentSession = _outboxedSessionFactory.OpenSession(context);
             var eventStore = documentSession.Events;
             var aggregateId = incrementA.LetterAggregateId;
             
             // Loading Marten aggregate
-            var eventStream = await eventStore.FetchForWriting<MartenTests.LetterAggregate>(aggregateId, cancellation).ConfigureAwait(false);
+            var eventStream = await eventStore.FetchForWriting<LetterAggregate>(aggregateId, cancellation).ConfigureAwait(false);
 
-            var letterAggregateHandler = new MartenTests.LetterAggregateHandler();
+            var letterAggregateHandler = new LetterAggregateHandler();
             
             // The actual message execution
             var outgoing1 = letterAggregateHandler.Handle(incrementA, eventStream.Aggregate, documentSession);
diff --git a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementBCHandler483010622.cs b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementBCHandler483010622.cs
index a270ed67c..06785bc8e 100644
--- a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementBCHandler483010622.cs
+++ b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementBCHandler483010622.cs
@@ -1,5 +1,6 @@
 // <auto-generated/>
 #pragma warning disable
+using MartenTests.AggregateHandlerWorkflow;
 using Wolverine.Marten.Publishing;
 
 namespace Internal.Generated.WolverineHandlers
@@ -19,16 +20,16 @@ public IncrementBCHandler483010622(Wolverine.Marten.Publishing.OutboxedSessionFa
         public override async System.Threading.Tasks.Task HandleAsync(Wolverine.Runtime.MessageContext context, System.Threading.CancellationToken cancellation)
         {
             // The actual message body
-            var incrementBC = (MartenTests.IncrementBC)context.Envelope.Message;
+            var incrementBC = (IncrementBC)context.Envelope.Message;
 
             await using var documentSession = _outboxedSessionFactory.OpenSession(context);
             var eventStore = documentSession.Events;
             var aggregateId = incrementBC.LetterAggregateId;
             
             // Loading Marten aggregate
-            var eventStream = await eventStore.FetchForWriting<MartenTests.LetterAggregate>(aggregateId, incrementBC.Version, cancellation).ConfigureAwait(false);
+            var eventStream = await eventStore.FetchForWriting<LetterAggregate>(aggregateId, incrementBC.Version, cancellation).ConfigureAwait(false);
 
-            var letterAggregateHandler = new MartenTests.LetterAggregateHandler();
+            var letterAggregateHandler = new LetterAggregateHandler();
             
             // The actual message execution
             var outgoing1 = letterAggregateHandler.Handle(incrementBC, eventStream.Aggregate);
diff --git a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementBHandler1255189857.cs b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementBHandler1255189857.cs
index b7bde7438..1533d8d9c 100644
--- a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementBHandler1255189857.cs
+++ b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementBHandler1255189857.cs
@@ -1,5 +1,6 @@
 // <auto-generated/>
 #pragma warning disable
+using MartenTests.AggregateHandlerWorkflow;
 using Microsoft.Extensions.Logging;
 using Wolverine.Marten.Publishing;
 
@@ -9,9 +10,9 @@ namespace Internal.Generated.WolverineHandlers
     public class IncrementBHandler1255189857 : Wolverine.Runtime.Handlers.MessageHandler
     {
         private readonly Wolverine.Marten.Publishing.OutboxedSessionFactory _outboxedSessionFactory;
-        private readonly Microsoft.Extensions.Logging.ILogger<MartenTests.LetterAggregateHandler> _logger;
+        private readonly Microsoft.Extensions.Logging.ILogger<LetterAggregateHandler> _logger;
 
-        public IncrementBHandler1255189857(Wolverine.Marten.Publishing.OutboxedSessionFactory outboxedSessionFactory, Microsoft.Extensions.Logging.ILogger<MartenTests.LetterAggregateHandler> logger)
+        public IncrementBHandler1255189857(Wolverine.Marten.Publishing.OutboxedSessionFactory outboxedSessionFactory, Microsoft.Extensions.Logging.ILogger<LetterAggregateHandler> logger)
         {
             _outboxedSessionFactory = outboxedSessionFactory;
             _logger = logger;
@@ -22,16 +23,16 @@ public IncrementBHandler1255189857(Wolverine.Marten.Publishing.OutboxedSessionFa
         public override async System.Threading.Tasks.Task HandleAsync(Wolverine.Runtime.MessageContext context, System.Threading.CancellationToken cancellation)
         {
             // The actual message body
-            var incrementB = (MartenTests.IncrementB)context.Envelope.Message;
+            var incrementB = (IncrementB)context.Envelope.Message;
 
             await using var documentSession = _outboxedSessionFactory.OpenSession(context);
             var eventStore = documentSession.Events;
             var aggregateId = incrementB.LetterAggregateId;
             
             // Loading Marten aggregate
-            var eventStream = await eventStore.FetchForWriting<MartenTests.LetterAggregate>(aggregateId, cancellation).ConfigureAwait(false);
+            var eventStream = await eventStore.FetchForWriting<LetterAggregate>(aggregateId, cancellation).ConfigureAwait(false);
 
-            var letterAggregateHandler = new MartenTests.LetterAggregateHandler();
+            var letterAggregateHandler = new LetterAggregateHandler();
             
             // The actual message execution
             var outgoing1 = await letterAggregateHandler.Handle(incrementB, eventStream.Aggregate, _logger).ConfigureAwait(false);
diff --git a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementCDHandler1083073314.cs b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementCDHandler1083073314.cs
index 5af373ff5..be29ff00b 100644
--- a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementCDHandler1083073314.cs
+++ b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementCDHandler1083073314.cs
@@ -1,5 +1,6 @@
 // <auto-generated/>
 #pragma warning disable
+using MartenTests.AggregateHandlerWorkflow;
 using Wolverine.Marten.Publishing;
 
 namespace Internal.Generated.WolverineHandlers
@@ -19,16 +20,16 @@ public IncrementCDHandler1083073314(Wolverine.Marten.Publishing.OutboxedSessionF
         public override async System.Threading.Tasks.Task HandleAsync(Wolverine.Runtime.MessageContext context, System.Threading.CancellationToken cancellation)
         {
             // The actual message body
-            var incrementCD = (MartenTests.IncrementCD)context.Envelope.Message;
+            var incrementCD = (IncrementCD)context.Envelope.Message;
 
             await using var documentSession = _outboxedSessionFactory.OpenSession(context);
             var eventStore = documentSession.Events;
             var aggregateId = incrementCD.LetterAggregateId;
             
             // Loading Marten aggregate
-            var eventStream = await eventStore.FetchForWriting<MartenTests.LetterAggregate>(aggregateId, incrementCD.Version, cancellation).ConfigureAwait(false);
+            var eventStream = await eventStore.FetchForWriting<LetterAggregate>(aggregateId, incrementCD.Version, cancellation).ConfigureAwait(false);
 
-            var letterAggregateHandler = new MartenTests.LetterAggregateHandler();
+            var letterAggregateHandler = new LetterAggregateHandler();
             
             // The actual message execution
             (var outgoing1, var outgoing2) = letterAggregateHandler.Handle(incrementCD, eventStream.Aggregate);
diff --git a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementCHandler1473693498.cs b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementCHandler1473693498.cs
index 005af4f00..23ebebe4e 100644
--- a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementCHandler1473693498.cs
+++ b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementCHandler1473693498.cs
@@ -1,5 +1,6 @@
 // <auto-generated/>
 #pragma warning disable
+using MartenTests.AggregateHandlerWorkflow;
 using Wolverine.Marten.Publishing;
 
 namespace Internal.Generated.WolverineHandlers
@@ -19,16 +20,16 @@ public IncrementCHandler1473693498(Wolverine.Marten.Publishing.OutboxedSessionFa
         public override async System.Threading.Tasks.Task HandleAsync(Wolverine.Runtime.MessageContext context, System.Threading.CancellationToken cancellation)
         {
             // The actual message body
-            var incrementC = (MartenTests.IncrementC)context.Envelope.Message;
+            var incrementC = (IncrementC)context.Envelope.Message;
 
             await using var documentSession = _outboxedSessionFactory.OpenSession(context);
             var eventStore = documentSession.Events;
             var aggregateId = incrementC.LetterAggregateId;
             
             // Loading Marten aggregate
-            var eventStream = await eventStore.FetchForWriting<MartenTests.LetterAggregate>(aggregateId, cancellation).ConfigureAwait(false);
+            var eventStream = await eventStore.FetchForWriting<LetterAggregate>(aggregateId, cancellation).ConfigureAwait(false);
 
-            var letterAggregateHandler = new MartenTests.LetterAggregateHandler();
+            var letterAggregateHandler = new LetterAggregateHandler();
             
             // The actual message execution
             letterAggregateHandler.Handle(incrementC, eventStream);
diff --git a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementDHandler1876978025.cs b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementDHandler1876978025.cs
index 3878627c9..7ba0e8c60 100644
--- a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementDHandler1876978025.cs
+++ b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementDHandler1876978025.cs
@@ -1,5 +1,6 @@
 // <auto-generated/>
 #pragma warning disable
+using MartenTests.AggregateHandlerWorkflow;
 using Wolverine.Marten.Publishing;
 
 namespace Internal.Generated.WolverineHandlers
@@ -19,16 +20,16 @@ public IncrementDHandler1876978025(Wolverine.Marten.Publishing.OutboxedSessionFa
         public override async System.Threading.Tasks.Task HandleAsync(Wolverine.Runtime.MessageContext context, System.Threading.CancellationToken cancellation)
         {
             // The actual message body
-            var incrementD = (MartenTests.IncrementD)context.Envelope.Message;
+            var incrementD = (IncrementD)context.Envelope.Message;
 
             await using var documentSession = _outboxedSessionFactory.OpenSession(context);
             var eventStore = documentSession.Events;
             var aggregateId = incrementD.LetterAggregateId;
             
             // Loading Marten aggregate
-            var eventStream = await eventStore.FetchForWriting<MartenTests.LetterAggregate>(aggregateId, cancellation).ConfigureAwait(false);
+            var eventStream = await eventStore.FetchForWriting<LetterAggregate>(aggregateId, cancellation).ConfigureAwait(false);
 
-            var letterAggregateHandler = new MartenTests.LetterAggregateHandler();
+            var letterAggregateHandler = new LetterAggregateHandler();
             
             // The actual message execution
             await letterAggregateHandler.Handle(incrementD, eventStream).ConfigureAwait(false);
diff --git a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementManyAsyncHandler2038967698.cs b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementManyAsyncHandler2038967698.cs
index 92f977d32..5f2fb8ab6 100644
--- a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementManyAsyncHandler2038967698.cs
+++ b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementManyAsyncHandler2038967698.cs
@@ -1,5 +1,6 @@
 // <auto-generated/>
 #pragma warning disable
+using MartenTests.AggregateHandlerWorkflow;
 using Wolverine.Marten.Publishing;
 
 namespace Internal.Generated.WolverineHandlers
@@ -19,16 +20,16 @@ public IncrementManyAsyncHandler2038967698(Wolverine.Marten.Publishing.OutboxedS
         public override async System.Threading.Tasks.Task HandleAsync(Wolverine.Runtime.MessageContext context, System.Threading.CancellationToken cancellation)
         {
             // The actual message body
-            var incrementManyAsync = (MartenTests.IncrementManyAsync)context.Envelope.Message;
+            var incrementManyAsync = (IncrementManyAsync)context.Envelope.Message;
 
             await using var documentSession = _outboxedSessionFactory.OpenSession(context);
             var eventStore = documentSession.Events;
             var aggregateId = incrementManyAsync.LetterAggregateId;
             
             // Loading Marten aggregate
-            var eventStream = await eventStore.FetchForWriting<MartenTests.LetterAggregate>(aggregateId, cancellation).ConfigureAwait(false);
+            var eventStream = await eventStore.FetchForWriting<LetterAggregate>(aggregateId, cancellation).ConfigureAwait(false);
 
-            var letterAggregateHandler = new MartenTests.LetterAggregateHandler();
+            var letterAggregateHandler = new LetterAggregateHandler();
             
             // The actual message execution
             var outgoing1 = await letterAggregateHandler.Handle(incrementManyAsync, eventStream.Aggregate, documentSession).ConfigureAwait(false);
diff --git a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementManyHandler1569177634.cs b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementManyHandler1569177634.cs
index 09930a6f0..f1d2de734 100644
--- a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementManyHandler1569177634.cs
+++ b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/IncrementManyHandler1569177634.cs
@@ -1,5 +1,6 @@
 // <auto-generated/>
 #pragma warning disable
+using MartenTests.AggregateHandlerWorkflow;
 using Wolverine.Marten.Publishing;
 
 namespace Internal.Generated.WolverineHandlers
@@ -19,16 +20,16 @@ public IncrementManyHandler1569177634(Wolverine.Marten.Publishing.OutboxedSessio
         public override async System.Threading.Tasks.Task HandleAsync(Wolverine.Runtime.MessageContext context, System.Threading.CancellationToken cancellation)
         {
             // The actual message body
-            var incrementMany = (MartenTests.IncrementMany)context.Envelope.Message;
+            var incrementMany = (IncrementMany)context.Envelope.Message;
 
             await using var documentSession = _outboxedSessionFactory.OpenSession(context);
             var eventStore = documentSession.Events;
             var aggregateId = incrementMany.LetterAggregateId;
             
             // Loading Marten aggregate
-            var eventStream = await eventStore.FetchForWriting<MartenTests.LetterAggregate>(aggregateId, cancellation).ConfigureAwait(false);
+            var eventStream = await eventStore.FetchForWriting<LetterAggregate>(aggregateId, cancellation).ConfigureAwait(false);
 
-            var letterAggregateHandler = new MartenTests.LetterAggregateHandler();
+            var letterAggregateHandler = new LetterAggregateHandler();
             
             // The actual message execution
             var outgoing1 = letterAggregateHandler.Handle(incrementMany, eventStream.Aggregate, documentSession);
diff --git a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/LetterMessage1Handler726704086.cs b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/LetterMessage1Handler726704086.cs
index 91b56d1f1..c02307a80 100644
--- a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/LetterMessage1Handler726704086.cs
+++ b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/LetterMessage1Handler726704086.cs
@@ -1,4 +1,7 @@
 // <auto-generated/>
+
+using MartenTests.AggregateHandlerWorkflow;
+
 #pragma warning disable
 
 namespace Internal.Generated.WolverineHandlers
@@ -11,11 +14,11 @@ public class LetterMessage1Handler726704086 : Wolverine.Runtime.Handlers.Message
         public override System.Threading.Tasks.Task HandleAsync(Wolverine.Runtime.MessageContext context, System.Threading.CancellationToken cancellation)
         {
             // The actual message body
-            var letterMessage1 = (MartenTests.LetterMessage1)context.Envelope.Message;
+            var letterMessage1 = (LetterMessage1)context.Envelope.Message;
 
             
             // The actual message execution
-            MartenTests.ResponseHandler.Handle(letterMessage1);
+            ResponseHandler.Handle(letterMessage1);
 
             return System.Threading.Tasks.Task.CompletedTask;
         }
diff --git a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/LetterMessage2Handler839379855.cs b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/LetterMessage2Handler839379855.cs
index 6b50ecd97..6b9496b8f 100644
--- a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/LetterMessage2Handler839379855.cs
+++ b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/LetterMessage2Handler839379855.cs
@@ -1,4 +1,7 @@
 // <auto-generated/>
+
+using MartenTests.AggregateHandlerWorkflow;
+
 #pragma warning disable
 
 namespace Internal.Generated.WolverineHandlers
@@ -11,11 +14,11 @@ public class LetterMessage2Handler839379855 : Wolverine.Runtime.Handlers.Message
         public override System.Threading.Tasks.Task HandleAsync(Wolverine.Runtime.MessageContext context, System.Threading.CancellationToken cancellation)
         {
             // The actual message body
-            var letterMessage2 = (MartenTests.LetterMessage2)context.Envelope.Message;
+            var letterMessage2 = (LetterMessage2)context.Envelope.Message;
 
             
             // The actual message execution
-            MartenTests.ResponseHandler.Handle(letterMessage2);
+            ResponseHandler.Handle(letterMessage2);
 
             return System.Threading.Tasks.Task.CompletedTask;
         }
diff --git a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/Outgoing1Handler1264108911.cs b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/Outgoing1Handler1264108911.cs
index 76d510674..4ab22de91 100644
--- a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/Outgoing1Handler1264108911.cs
+++ b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/Outgoing1Handler1264108911.cs
@@ -1,4 +1,7 @@
 // <auto-generated/>
+
+using MartenTests.AggregateHandlerWorkflow;
+
 #pragma warning disable
 
 namespace Internal.Generated.WolverineHandlers
@@ -11,11 +14,11 @@ public class Outgoing1Handler1264108911 : Wolverine.Runtime.Handlers.MessageHand
         public override System.Threading.Tasks.Task HandleAsync(Wolverine.Runtime.MessageContext context, System.Threading.CancellationToken cancellation)
         {
             // The actual message body
-            var outgoing1 = (MartenTests.Outgoing1)context.Envelope.Message;
+            var outgoing1 = (Outgoing1)context.Envelope.Message;
 
             
             // The actual message execution
-            MartenTests.Outgoing1Handler.Handle(outgoing1);
+            Outgoing1Handler.Handle(outgoing1);
 
             return System.Threading.Tasks.Task.CompletedTask;
         }
diff --git a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/RaiseAAAHandler1649029811.cs b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/RaiseAAAHandler1649029811.cs
index 4a042b060..5ee007558 100644
--- a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/RaiseAAAHandler1649029811.cs
+++ b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/RaiseAAAHandler1649029811.cs
@@ -1,5 +1,6 @@
 // <auto-generated/>
 #pragma warning disable
+using MartenTests.AggregateHandlerWorkflow;
 using Wolverine.Marten.Publishing;
 
 namespace Internal.Generated.WolverineHandlers
@@ -19,18 +20,18 @@ public RaiseAAAHandler1649029811(Wolverine.Marten.Publishing.OutboxedSessionFact
         public override async System.Threading.Tasks.Task HandleAsync(Wolverine.Runtime.MessageContext context, System.Threading.CancellationToken cancellation)
         {
             // The actual message body
-            var raiseAAA = (MartenTests.RaiseAAA)context.Envelope.Message;
+            var raiseAAA = (RaiseAAA)context.Envelope.Message;
 
             await using var documentSession = _outboxedSessionFactory.OpenSession(context);
             var eventStore = documentSession.Events;
             var aggregateId = raiseAAA.LetterAggregateId;
             
             // Loading Marten aggregate
-            var eventStream = await eventStore.FetchForWriting<MartenTests.LetterAggregate>(aggregateId, cancellation).ConfigureAwait(false);
+            var eventStream = await eventStore.FetchForWriting<LetterAggregate>(aggregateId, cancellation).ConfigureAwait(false);
 
             
             // The actual message execution
-            var outgoing1 = MartenTests.RaiseLetterHandler.Handle(raiseAAA, eventStream);
+            var outgoing1 = RaiseLetterHandler.Handle(raiseAAA, eventStream);
 
             
             // Outgoing, cascaded message
diff --git a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/RaiseAABCCHandler1413048758.cs b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/RaiseAABCCHandler1413048758.cs
index 2855d7e4c..821738fb4 100644
--- a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/RaiseAABCCHandler1413048758.cs
+++ b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/RaiseAABCCHandler1413048758.cs
@@ -1,5 +1,6 @@
 // <auto-generated/>
 #pragma warning disable
+using MartenTests.AggregateHandlerWorkflow;
 using Wolverine.Marten.Publishing;
 
 namespace Internal.Generated.WolverineHandlers
@@ -19,18 +20,18 @@ public RaiseAABCCHandler1413048758(Wolverine.Marten.Publishing.OutboxedSessionFa
         public override async System.Threading.Tasks.Task HandleAsync(Wolverine.Runtime.MessageContext context, System.Threading.CancellationToken cancellation)
         {
             // The actual message body
-            var raiseAABCC = (MartenTests.RaiseAABCC)context.Envelope.Message;
+            var raiseAABCC = (RaiseAABCC)context.Envelope.Message;
 
             await using var documentSession = _outboxedSessionFactory.OpenSession(context);
             var eventStore = documentSession.Events;
             var aggregateId = raiseAABCC.LetterAggregateId;
             
             // Loading Marten aggregate
-            var eventStream = await eventStore.FetchForWriting<MartenTests.LetterAggregate>(aggregateId, cancellation).ConfigureAwait(false);
+            var eventStream = await eventStore.FetchForWriting<LetterAggregate>(aggregateId, cancellation).ConfigureAwait(false);
 
             
             // The actual message execution
-            (var outgoing1, var outgoing2) = MartenTests.RaiseLetterHandler.Handle(raiseAABCC, eventStream.Aggregate);
+            (var outgoing1, var outgoing2) = RaiseLetterHandler.Handle(raiseAABCC, eventStream.Aggregate);
 
             
             // Outgoing, cascaded message
diff --git a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/RaiseABCHandler1483138068.cs b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/RaiseABCHandler1483138068.cs
index 4115246fd..173028cd6 100644
--- a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/RaiseABCHandler1483138068.cs
+++ b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/RaiseABCHandler1483138068.cs
@@ -1,5 +1,6 @@
 // <auto-generated/>
 #pragma warning disable
+using MartenTests.AggregateHandlerWorkflow;
 using Wolverine.Marten.Publishing;
 
 namespace Internal.Generated.WolverineHandlers
@@ -19,18 +20,18 @@ public RaiseABCHandler1483138068(Wolverine.Marten.Publishing.OutboxedSessionFact
         public override async System.Threading.Tasks.Task HandleAsync(Wolverine.Runtime.MessageContext context, System.Threading.CancellationToken cancellation)
         {
             // The actual message body
-            var raiseABC = (MartenTests.RaiseABC)context.Envelope.Message;
+            var raiseABC = (RaiseABC)context.Envelope.Message;
 
             await using var documentSession = _outboxedSessionFactory.OpenSession(context);
             var eventStore = documentSession.Events;
             var aggregateId = raiseABC.LetterAggregateId;
             
             // Loading Marten aggregate
-            var eventStream = await eventStore.FetchForWriting<MartenTests.LetterAggregate>(aggregateId, cancellation).ConfigureAwait(false);
+            var eventStream = await eventStore.FetchForWriting<LetterAggregate>(aggregateId, cancellation).ConfigureAwait(false);
 
             
             // The actual message execution
-            (var outgoing1, var outgoing2) = MartenTests.RaiseLetterHandler.Handle(raiseABC, eventStream.Aggregate);
+            (var outgoing1, var outgoing2) = RaiseLetterHandler.Handle(raiseABC, eventStream.Aggregate);
 
             if (outgoing1 != null)
             {
diff --git a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/RaiseBBCCCHandler1900945687.cs b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/RaiseBBCCCHandler1900945687.cs
index 25b27a6ee..816db5085 100644
--- a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/RaiseBBCCCHandler1900945687.cs
+++ b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/RaiseBBCCCHandler1900945687.cs
@@ -1,5 +1,6 @@
 // <auto-generated/>
 #pragma warning disable
+using MartenTests.AggregateHandlerWorkflow;
 using Wolverine.Marten.Publishing;
 
 namespace Internal.Generated.WolverineHandlers
@@ -19,18 +20,18 @@ public RaiseBBCCCHandler1900945687(Wolverine.Marten.Publishing.OutboxedSessionFa
         public override async System.Threading.Tasks.Task HandleAsync(Wolverine.Runtime.MessageContext context, System.Threading.CancellationToken cancellation)
         {
             // The actual message body
-            var raiseBBCCC = (MartenTests.RaiseBBCCC)context.Envelope.Message;
+            var raiseBBCCC = (RaiseBBCCC)context.Envelope.Message;
 
             await using var documentSession = _outboxedSessionFactory.OpenSession(context);
             var eventStore = documentSession.Events;
             var aggregateId = raiseBBCCC.LetterAggregateId;
             
             // Loading Marten aggregate
-            var eventStream = await eventStore.FetchForWriting<MartenTests.LetterAggregate>(aggregateId, cancellation).ConfigureAwait(false);
+            var eventStream = await eventStore.FetchForWriting<LetterAggregate>(aggregateId, cancellation).ConfigureAwait(false);
 
             
             // The actual message execution
-            (var outgoing1, var outgoing2, var outgoing3) = MartenTests.RaiseLetterHandler.Handle(raiseBBCCC, eventStream.Aggregate);
+            (var outgoing1, var outgoing2, var outgoing3) = RaiseLetterHandler.Handle(raiseBBCCC, eventStream.Aggregate);
 
             
             // Outgoing, cascaded message
diff --git a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/RaiseHandler985277900.cs b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/RaiseHandler985277900.cs
index 30584d0f9..bece68216 100644
--- a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/RaiseHandler985277900.cs
+++ b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/RaiseHandler985277900.cs
@@ -1,5 +1,6 @@
 // <auto-generated/>
 #pragma warning disable
+using MartenTests.AggregateHandlerWorkflow;
 using Wolverine.Marten.Publishing;
 
 namespace Internal.Generated.WolverineHandlers
@@ -19,18 +20,18 @@ public RaiseHandler985277900(Wolverine.Marten.Publishing.OutboxedSessionFactory
         public override async System.Threading.Tasks.Task HandleAsync(Wolverine.Runtime.MessageContext context, System.Threading.CancellationToken cancellation)
         {
             // The actual message body
-            var raise = (MartenTests.Raise)context.Envelope.Message;
+            var raise = (Raise)context.Envelope.Message;
 
             await using var documentSession = _outboxedSessionFactory.OpenSession(context);
             var eventStore = documentSession.Events;
             var aggregateId = raise.LetterAggregateId;
             
             // Loading Marten aggregate
-            var eventStream = await eventStore.FetchForWriting<MartenTests.LetterAggregate>(aggregateId, cancellation).ConfigureAwait(false);
+            var eventStream = await eventStore.FetchForWriting<LetterAggregate>(aggregateId, cancellation).ConfigureAwait(false);
 
             
             // The actual message execution
-            (var outgoing1, var outgoing2) = MartenTests.RaiseLetterHandler.Handle(raise, eventStream.Aggregate);
+            (var outgoing1, var outgoing2) = RaiseLetterHandler.Handle(raise, eventStream.Aggregate);
 
             
             // Outgoing, cascaded message
@@ -45,7 +46,7 @@ public override async System.Threading.Tasks.Task HandleAsync(Wolverine.Runtime.
             }
 
             await documentSession.SaveChangesAsync(cancellation).ConfigureAwait(false);
-            var response_of_letterAggregate = await eventStore.FetchLatest<MartenTests.LetterAggregate>(aggregateId, cancellation);
+            var response_of_letterAggregate = await eventStore.FetchLatest<LetterAggregate>(aggregateId, cancellation);
             
             // Outgoing, cascaded message
             await context.EnqueueCascadingAsync(response_of_letterAggregate).ConfigureAwait(false);
diff --git a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/RaiseIfValidatedHandler2071345539.cs b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/RaiseIfValidatedHandler2071345539.cs
index f0c1ee1d7..419515e42 100644
--- a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/RaiseIfValidatedHandler2071345539.cs
+++ b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/RaiseIfValidatedHandler2071345539.cs
@@ -1,5 +1,6 @@
 // <auto-generated/>
 #pragma warning disable
+using MartenTests.AggregateHandlerWorkflow;
 using Wolverine.Marten.Publishing;
 
 namespace Internal.Generated.WolverineHandlers
@@ -19,21 +20,21 @@ public RaiseIfValidatedHandler2071345539(Wolverine.Marten.Publishing.OutboxedSes
         public override async System.Threading.Tasks.Task HandleAsync(Wolverine.Runtime.MessageContext context, System.Threading.CancellationToken cancellation)
         {
             // The actual message body
-            var raiseIfValidated = (MartenTests.RaiseIfValidated)context.Envelope.Message;
+            var raiseIfValidated = (RaiseIfValidated)context.Envelope.Message;
 
             await using var documentSession = _outboxedSessionFactory.OpenSession(context);
             var eventStore = documentSession.Events;
             var aggregateId = raiseIfValidated.LetterAggregateId;
             
             // Loading Marten aggregate
-            var eventStream = await eventStore.FetchForWriting<MartenTests.LetterAggregate>(aggregateId, cancellation).ConfigureAwait(false);
+            var eventStream = await eventStore.FetchForWriting<LetterAggregate>(aggregateId, cancellation).ConfigureAwait(false);
 
-            var result_of_Validate1 = MartenTests.RaiseIfValidatedHandler.Validate(eventStream.Aggregate);
+            var result_of_Validate1 = RaiseIfValidatedHandler.Validate(eventStream.Aggregate);
             // Evaluate whether or not the execution should stop based on the HandlerContinuation value
             if (result_of_Validate1 == Wolverine.HandlerContinuation.Stop) return;
             
             // The actual message execution
-            var outgoing1 = MartenTests.RaiseIfValidatedHandler.Handle(raiseIfValidated, eventStream.Aggregate);
+            var outgoing1 = RaiseIfValidatedHandler.Handle(raiseIfValidated, eventStream.Aggregate);
 
             if (outgoing1 != null)
             {
diff --git a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/RaiseLotsAsyncHandler89313884.cs b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/RaiseLotsAsyncHandler89313884.cs
index 75a011399..6c842cbc1 100644
--- a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/RaiseLotsAsyncHandler89313884.cs
+++ b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/RaiseLotsAsyncHandler89313884.cs
@@ -1,5 +1,6 @@
 // <auto-generated/>
 #pragma warning disable
+using MartenTests.AggregateHandlerWorkflow;
 using Wolverine.Marten.Publishing;
 
 namespace Internal.Generated.WolverineHandlers
@@ -19,18 +20,18 @@ public RaiseLotsAsyncHandler89313884(Wolverine.Marten.Publishing.OutboxedSession
         public override async System.Threading.Tasks.Task HandleAsync(Wolverine.Runtime.MessageContext context, System.Threading.CancellationToken cancellation)
         {
             // The actual message body
-            var raiseLotsAsync = (MartenTests.RaiseLotsAsync)context.Envelope.Message;
+            var raiseLotsAsync = (RaiseLotsAsync)context.Envelope.Message;
 
             await using var documentSession = _outboxedSessionFactory.OpenSession(context);
             var eventStore = documentSession.Events;
             var aggregateId = raiseLotsAsync.LetterAggregateId;
             
             // Loading Marten aggregate
-            var eventStream = await eventStore.FetchForWriting<MartenTests.LetterAggregate>(aggregateId, cancellation).ConfigureAwait(false);
+            var eventStream = await eventStore.FetchForWriting<LetterAggregate>(aggregateId, cancellation).ConfigureAwait(false);
 
             
             // The actual message execution
-            var outgoing1 = MartenTests.RaiseLetterHandler.Handle(raiseLotsAsync, eventStream.Aggregate);
+            var outgoing1 = RaiseLetterHandler.Handle(raiseLotsAsync, eventStream.Aggregate);
 
             // Apply events to Marten event stream
             await foreach (var letterAggregateEvent in outgoing1) eventStream.AppendOne(letterAggregateEvent);
diff --git a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/RaiseOnlyDHandler1609388090.cs b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/RaiseOnlyDHandler1609388090.cs
index 167aa9efb..e1acb7669 100644
--- a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/RaiseOnlyDHandler1609388090.cs
+++ b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/RaiseOnlyDHandler1609388090.cs
@@ -1,5 +1,6 @@
 // <auto-generated/>
 #pragma warning disable
+using MartenTests.AggregateHandlerWorkflow;
 using Wolverine.Marten.Publishing;
 
 namespace Internal.Generated.WolverineHandlers
@@ -19,18 +20,18 @@ public RaiseOnlyDHandler1609388090(Wolverine.Marten.Publishing.OutboxedSessionFa
         public override async System.Threading.Tasks.Task HandleAsync(Wolverine.Runtime.MessageContext context, System.Threading.CancellationToken cancellation)
         {
             // The actual message body
-            var raiseOnlyD = (MartenTests.RaiseOnlyD)context.Envelope.Message;
+            var raiseOnlyD = (RaiseOnlyD)context.Envelope.Message;
 
             await using var documentSession = _outboxedSessionFactory.OpenSession(context);
             var eventStore = documentSession.Events;
             var aggregateId = raiseOnlyD.LetterAggregateId;
             
             // Loading Marten aggregate
-            var eventStream = await eventStore.FetchForWriting<MartenTests.LetterAggregate>(aggregateId, cancellation).ConfigureAwait(false);
+            var eventStream = await eventStore.FetchForWriting<LetterAggregate>(aggregateId, cancellation).ConfigureAwait(false);
 
             
             // The actual message execution
-            var outgoing1 = MartenTests.RaiseLetterHandler.Handle(raiseOnlyD, eventStream.Aggregate);
+            var outgoing1 = RaiseLetterHandler.Handle(raiseOnlyD, eventStream.Aggregate);
 
             eventStream.AppendOne(outgoing1);
             await documentSession.SaveChangesAsync(cancellation).ConfigureAwait(false);
diff --git a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/ResponseHandler2107844337.cs b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/ResponseHandler2107844337.cs
index 36b30592b..5f458b338 100644
--- a/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/ResponseHandler2107844337.cs
+++ b/src/Persistence/MartenTests/Internal/Generated/WolverineHandlers/ResponseHandler2107844337.cs
@@ -1,4 +1,7 @@
 // <auto-generated/>
+
+using MartenTests.AggregateHandlerWorkflow;
+
 #pragma warning disable
 
 namespace Internal.Generated.WolverineHandlers
@@ -11,11 +14,11 @@ public class ResponseHandler2107844337 : Wolverine.Runtime.Handlers.MessageHandl
         public override System.Threading.Tasks.Task HandleAsync(Wolverine.Runtime.MessageContext context, System.Threading.CancellationToken cancellation)
         {
             // The actual message body
-            var response = (MartenTests.Response)context.Envelope.Message;
+            var response = (Response)context.Envelope.Message;
 
             
             // The actual message execution
-            MartenTests.ResponseHandler.Handle(response);
+            ResponseHandler.Handle(response);
 
             return System.Threading.Tasks.Task.CompletedTask;
         }
diff --git a/src/Persistence/MartenTests/Subscriptions/subscriptions_end_to_end.cs b/src/Persistence/MartenTests/Subscriptions/subscriptions_end_to_end.cs
index d441ea9d7..c9086f8cd 100644
--- a/src/Persistence/MartenTests/Subscriptions/subscriptions_end_to_end.cs
+++ b/src/Persistence/MartenTests/Subscriptions/subscriptions_end_to_end.cs
@@ -7,6 +7,7 @@
 using Marten.Events;
 using Marten.Events.Daemon;
 using Marten.Events.Daemon.Internals;
+using MartenTests.AggregateHandlerWorkflow;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Npgsql;
diff --git a/src/Persistence/MartenTests/end_to_end_publish_messages_through_marten_to_wolverine.cs b/src/Persistence/MartenTests/end_to_end_publish_messages_through_marten_to_wolverine.cs
index 733b0a877..11150a4e6 100644
--- a/src/Persistence/MartenTests/end_to_end_publish_messages_through_marten_to_wolverine.cs
+++ b/src/Persistence/MartenTests/end_to_end_publish_messages_through_marten_to_wolverine.cs
@@ -12,6 +12,7 @@
 using Marten.Events.Projections;
 using Marten.Schema;
 using Marten.Storage;
+using MartenTests.AggregateHandlerWorkflow;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Npgsql;
diff --git a/src/Persistence/MartenTests/handler_actions_with_returned_StartStream.cs b/src/Persistence/MartenTests/handler_actions_with_returned_StartStream.cs
index 1838e81ea..c8ff2aa6c 100644
--- a/src/Persistence/MartenTests/handler_actions_with_returned_StartStream.cs
+++ b/src/Persistence/MartenTests/handler_actions_with_returned_StartStream.cs
@@ -5,6 +5,7 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using JasperFx.Resources;
+using MartenTests.AggregateHandlerWorkflow;
 using Shouldly;
 using Wolverine;
 using Wolverine.Marten;
diff --git a/src/Persistence/MartenTests/read_aggregate_attribute_usage.cs b/src/Persistence/MartenTests/read_aggregate_attribute_usage.cs
index 7ffc46ab8..e11338992 100644
--- a/src/Persistence/MartenTests/read_aggregate_attribute_usage.cs
+++ b/src/Persistence/MartenTests/read_aggregate_attribute_usage.cs
@@ -2,6 +2,7 @@
 using JasperFx.Resources;
 using Marten;
 using Marten.Events.Projections;
+using MartenTests.AggregateHandlerWorkflow;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Shouldly;
diff --git a/src/Persistence/MartenTests/using_an_aggregate_that_handles_commands.cs b/src/Persistence/MartenTests/using_an_aggregate_that_handles_commands.cs
index e0812e16e..ea1874e5d 100644
--- a/src/Persistence/MartenTests/using_an_aggregate_that_handles_commands.cs
+++ b/src/Persistence/MartenTests/using_an_aggregate_that_handles_commands.cs
@@ -7,6 +7,7 @@
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using JasperFx.Resources;
+using MartenTests.AggregateHandlerWorkflow;
 using Shouldly;
 using Wolverine;
 using Wolverine.Marten;
diff --git a/src/Persistence/Wolverine.Marten/AggregateHandlerAttribute.cs b/src/Persistence/Wolverine.Marten/AggregateHandlerAttribute.cs
index 871551def..273b429d7 100644
--- a/src/Persistence/Wolverine.Marten/AggregateHandlerAttribute.cs
+++ b/src/Persistence/Wolverine.Marten/AggregateHandlerAttribute.cs
@@ -4,6 +4,7 @@
 using JasperFx.CodeGeneration.Model;
 using JasperFx.Core;
 using JasperFx.Core.Reflection;
+using JasperFx.Events;
 using JasperFx.Events.Aggregation;
 using JasperFx.Events.Daemon;
 using Marten;
@@ -11,6 +12,7 @@
 using Marten.Events.Aggregation;
 using Marten.Linq.Members;
 using Marten.Schema;
+using Microsoft.Extensions.DependencyInjection;
 using Wolverine.Attributes;
 using Wolverine.Codegen;
 using Wolverine.Configuration;
@@ -67,17 +69,36 @@ public AggregateHandlerAttribute() : this(ConcurrencyStyle.Optimistic)
 
     public override void Modify(IChain chain, GenerationRules rules, IServiceContainer container)
     {
+        // ReSharper disable once CanSimplifyDictionaryLookupWithTryAdd
         if (chain.Tags.ContainsKey(nameof(AggregateHandlerAttribute))) return;
+        
         chain.Tags.Add(nameof(AggregateHandlerAttribute),"true");
 
         CommandType = chain.InputType();
         if (CommandType == null)
             throw new InvalidOperationException(
                 $"Cannot apply Marten aggregate handler workflow to chain {chain} because it has no input type");
-
+        
         AggregateType ??= DetermineAggregateType(chain);
-        AggregateIdMember = DetermineAggregateIdMember(AggregateType, CommandType);
-        VersionMember = DetermineVersionMember(CommandType);
+
+        if (CommandType.Closes(typeof(IEvent<>)))
+        {
+            var concreteEventType = typeof(Event<>).MakeGenericType(CommandType.GetGenericArguments()[0]);
+            
+            // This CANNOT work if you capture the version, because there's no way to know if the aggregate version
+            // has advanced
+            //VersionMember = concreteEventType.GetProperty(nameof(IEvent.Version));
+            
+            var options = container.Services.GetRequiredService<StoreOptions>();
+            AggregateIdMember = options.Events.StreamIdentity == StreamIdentity.AsGuid
+                ? concreteEventType.GetProperty(nameof(IEvent.StreamId), BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy)
+                : concreteEventType.GetProperty(nameof(IEvent.StreamKey), BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy);
+        }
+        else
+        {
+            AggregateIdMember = DetermineAggregateIdMember(AggregateType, CommandType);
+            VersionMember = DetermineVersionMember(CommandType);
+        }
 
         var sessionCreator = MethodCall.For<OutboxedSessionFactory>(x => x.OpenSession(null!));
         chain.Middleware.Add(sessionCreator);
@@ -206,7 +227,7 @@ internal Type DetermineAggregateType(IChain chain)
             return stream.ParameterType.GetGenericArguments().Single();
         }
 
-        if (parameters.Length >= 2 && parameters[1].ParameterType.IsConcrete())
+        if (parameters.Length >= 2 && (parameters[1].ParameterType.IsConcrete() || parameters[1].ParameterType.Closes(typeof(IEvent<>))))
         {
             return parameters[1].ParameterType;
         }
diff --git a/src/Wolverine/Configuration/HandlerDiscovery.Diagnostics.cs b/src/Wolverine/Configuration/HandlerDiscovery.Diagnostics.cs
index 9e689336a..8d46fa6b3 100644
--- a/src/Wolverine/Configuration/HandlerDiscovery.Diagnostics.cs
+++ b/src/Wolverine/Configuration/HandlerDiscovery.Diagnostics.cs
@@ -37,12 +37,15 @@ internal string DescribeHandlerMatch(WolverineOptions options, Type candidateTyp
             typeNotFound = true;
         }
 
-        if (typeNotFound)
+        if (typeNotFound && !_conventionalDiscoveryDisabled)
         {
             return writer.ToString();
         }
 
-        writer.WriteLine($"Successfully found {candidateType.FullNameInCode()} during scanning.");
+        if (!_conventionalDiscoveryDisabled)
+        {
+            writer.WriteLine($"Successfully found {candidateType.FullNameInCode()} during scanning.");
+        }
         writer.WriteLine("Methods:");
         writer.WriteLine();