@drunkcoding/dknet-implementation-skills 14.1.0 → 14.1.1

package/{skills → plugin/skills}/dknet-docs/templates/architecture-template.md

@@ -1,5 +1,11 @@
 # {FeatureName} — Architecture
 
+> Diagrams below are written as Mermaid so this template stays readable on its own. Render the
+> architecture, sequence, data-flow and lifecycle diagrams with **archify**
+> (<https://github.com/tt-a1i/archify>) and replace each fenced block with an image link to the
+> exported SVG in `diagrams/`, keeping the archify JSON source beside it. Keep `erDiagram` as
+> Mermaid — archify has no table-schema type. See the `dknet-docs` skill, *Diagrams*.
+
 ## Vertical Slice Overview
 
 This feature follows the DKNet vertical slice architecture.
@@ -9,11 +15,11 @@ Each layer has a single, focused responsibility for this feature.
 graph TD
     Client["Client / Browser"]
 
-    subgraph API["Minimal.Api"]
+    subgraph API["<YourApp>.Api"]
         EP["{EntityName}V1Endpoint\n(IEndpointConfig)"]
     end
 
-    subgraph AppServices["Minimal.AppServices"]
+    subgraph AppServices["<YourApp>.AppServices"]
         REQ["Request Types\n(Create / Update / Delete\n+ custom actions)"]
         VAL["Validators\n(FluentValidation)"]
         HDL["Command Handlers\n(IHandler)"]
@@ -21,11 +27,11 @@ graph TD
         EVT["Domain Events\n({EntityName}CreatedEvent etc.)"]
     end
 
-    subgraph Domains["Minimal.Domains"]
+    subgraph Domains["<YourApp>.Domains"]
         ENT["{EntityName}\n(AggregateRoot)"]
     end
 
-    subgraph Infra["Minimal.Infra"]
+    subgraph Infra["<YourApp>.Infra"]
         MAP["{EntityName}Mapper.cs\n(EF Core Config)"]
         REPO["IRepositorySpec\n(EF Core + Spec)"]
         EVH["Event Handlers\n(Azure Bus / In-Memory)"]
@@ -160,7 +166,7 @@ graph LR
 
 | Layer | Responsibility in this feature |
 |-------|-------------------------------|
-| `Minimal.Api` | Route mapping only; zero business logic |
-| `Minimal.AppServices` | Command handling, validation, event publishing |
-| `Minimal.Domains` | Entity state, domain rules, invariants |
-| `Minimal.Infra` | Persistence, EF Core config, message bus setup |
+| `<YourApp>.Api` | Route mapping only; zero business logic |
+| `<YourApp>.AppServices` | Command handling, validation, event publishing |
+| `<YourApp>.Domains` | Entity state, domain rules, invariants |
+| `<YourApp>.Infra` | Persistence, EF Core config, message bus setup |

package/{skills → plugin/skills}/dknet-docs/templates/data-model-template.md

@@ -50,7 +50,7 @@ erDiagram
 
 ## EF Core Mapping Configuration
 
-Source: `ApiEndpoints/Minimal.Infra/Features/{EntityFolder}/Mappers/{EntityName}Mapper.cs`
+Source: `ApiEndpoints/<YourApp>.Infra/Features/{EntityFolder}/Mappers/{EntityName}Mapper.cs`
 
 Key mapping decisions:
 
@@ -96,4 +96,4 @@ Key mapping decisions:
 | `Initial_{EntityName}` | Create initial `{EntityTableName}` table |
 | `Add_{Field}_To_{EntityName}` | {Reason for the change} |
 
-> Keep this table updated when running `dotnet ef migrations add <Name> -c CoreDbContext -p Minimal.Infra/Minimal.Infra.csproj`.
+> Keep this table updated when running `dotnet ef migrations add <Name> -c CoreDbContext -p <YourApp>.Infra/<YourApp>.Infra.csproj`.

package/{skills → plugin/skills}/dknet-docs/templates/events-template.md

@@ -104,14 +104,14 @@ This feature does not currently consume events from other features.
 
 ## Event Bus Configuration
 
-Events are dispatched via the Minimal message bus with two bus types:
+Events are dispatched via the solution's SlimMessageBus with two bus types:
 
 | Bus Type | When Active | Purpose |
 |----------|-------------|---------|
 | **In-Memory** | Always (all environments) | Same-process handlers; local side effects |
 | **Azure Service Bus** | When `ConnectionStrings:AzureBus` is non-empty | Cross-service/process messaging |
 
-See `ApiEndpoints/Minimal.Infra/Extensions/ServiceBusSetup.cs` for wiring configuration.
+See `ApiEndpoints/<YourApp>.Infra/Extensions/ServiceBusSetup.cs` for wiring configuration.
 
 ```mermaid
 graph LR

package/{skills → plugin/skills}/dknet-dto-mapping/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: dknet-dto-mapping
-description: Design response DTOs and Mapster mapping for a DKNet.Minimal feature — hand-written vs [GenerateDto] shapes, custom Mapster IRegister mappings for values the generator's convention can't produce, LazyMapper, and the JSON/sensitive-data contract. Use after (or alongside) dknet-crud when a handler needs a DTO to return.
+description: Design response DTOs and Mapster mapping for a DKNet.Minimal feature — [GenerateDto] first and hand-written records as the fallback, custom Mapster IRegister mappings for values the generator's convention can't produce, LazyMapper, and the JSON/sensitive-data contract. Use after (or alongside) dknet-crud when a handler needs a DTO to return.
 ---
 
 # DTO and Mapster mapping
@@ -8,27 +8,15 @@ description: Design response DTOs and Mapster mapping for a DKNet.Minimal featur
 Response DTO shape and how it gets filled from the entity. For request contracts, validators and
 handlers, load `dknet-crud`. For paged query projections, load `dknet-queries-specs`.
 
-## Two DTO shapes
+## Two DTO shapes — `[GenerateDto]` first
 
-**Hand-written** — a plain record, exactly the fields you list:
-
-```csharp
-// ManualSample/V1/PurchaseOrderDto.cs
-public sealed record PurchaseOrderDto
-{
-    public Guid Id { get; init; }
-    public string CustomerName { get; init; } = null!;
-    public decimal Amount { get; init; }
-    public PurchaseOrderStatus Status { get; init; }
-    public string CreatedBy { get; init; } = null!;
-}
-```
-
-This carries **no attribute at all**, yet `mapper.Map<PurchaseOrderDto>(order)` and
-`mapper.ResultOf<PurchaseOrderDto>(order)` both work correctly. Mapster's global convention
-(`TypeAdapterConfig.GlobalSettings.Default`, configured once in `AppSetup.cs`) maps any two types by
-flexible name matching with no registration required — a hand-written DTO whose property names
-match the entity's needs nothing further.
+**Default to `[GenerateDto]`.** It keeps the DTO in step with the entity (a new property appears on
+the next build), carries `[SensitiveData]`/`[MaxLength]` across from the entity for free, and is what
+the generated CRUD and generic list routes read as their contract. Narrow it with `Exclude`/`Include`
+rather than abandoning it, and add a computed member on your own partial declaration rather than
+hand-writing the whole record. Hand-write a DTO only when the response must intentionally expose
+less than the entity *and* the feature has no generated route, or when a value needs CLR-only
+computation that could never be EF-translated.
 
 **Generated** — one attribute on an empty `partial record`:
 
@@ -67,6 +55,26 @@ that's how `SupplierCostPrice`/`SupplierReferenceCode` stay gated per caller (se
 `GrossMargin` is the file's one hand-written addition, on the *other*, non-generated partial
 declaration — the generator's output file is never edited directly.
 
+**Hand-written (fallback)** — a plain record, exactly the fields you list:
+
+```csharp
+// ManualSample/V1/PurchaseOrderDto.cs
+public sealed record PurchaseOrderDto
+{
+    public Guid Id { get; init; }
+    public string CustomerName { get; init; } = null!;
+    public decimal Amount { get; init; }
+    public PurchaseOrderStatus Status { get; init; }
+    public string CreatedBy { get; init; } = null!;
+}
+```
+
+This carries **no attribute at all**, yet `mapper.Map<PurchaseOrderDto>(order)` and
+`mapper.ResultOf<PurchaseOrderDto>(order)` both work correctly. Mapster's global convention
+(`TypeAdapterConfig.GlobalSettings.Default`, configured once in `AppSetup.cs`) maps any two types by
+flexible name matching with no registration required — a hand-written DTO whose property names
+match the entity's needs nothing further.
+
 ## `[GenerateDto]` options
 
 ```csharp
@@ -96,7 +104,7 @@ real mapped columns covering the same intent.
 
 ## Mapster global configuration
 
-`Minimal.AppServices/AppSetup.cs`, run once at startup:
+`<YourApp>.AppServices/AppSetup.cs`, run once at startup:
 
 ```csharp
 TypeAdapterConfig.GlobalSettings.Default.NameMatchingStrategy(NameMatchingStrategy.Flexible);
@@ -109,7 +117,7 @@ services.AddSingleton(TypeAdapterConfig.GlobalSettings)
         .AddScoped<IMapper, ServiceMapper>();
 ```
 
-`ScanMaps()` (`Minimal.AppServices/Extensions/MapsToExtensions.cs`) reflects over the assembly for
+`ScanMaps()` (`<YourApp>.AppServices/Extensions/MapsToExtensions.cs`) reflects over the assembly for
 every type carrying `[MapsFrom(typeof(Entity))]` or `[GenerateDto(typeof(Entity))]` and calls
 `config.NewConfig(entityType, dtoType)` for each — this is what makes a generated/`[MapsFrom]`-typed
 pair eagerly compiled and validated at startup, rather than resolved lazily by the `Default`
@@ -118,7 +126,7 @@ fallback rule on first use. **Ordering matters**: only *after* that loop does it
 merges their `ForType` customizations onto the config the loop just built. Reversing the order would
 have the convention's `NewConfig` wipe out the `IRegister`'s merge.
 
-`[MapsFrom]` on a hand-written DTO (`Minimal.AppServices.Extensions.MapsFromAttribute`) is **not
+`[MapsFrom]` on a hand-written DTO (`<YourApp>.AppServices.Extensions.MapsFromAttribute`) is **not
 required for the mapping to work** — `PurchaseOrderDto` proves that with zero attributes and zero
 registration. Reach for it only when you also want to attach a Mapster `IRegister` customization
 (a computed property, a rename) to that specific entity/DTO pair: `[MapsFrom]` puts the hand-written
@@ -215,7 +223,7 @@ carries its paging metadata (page number, total count) forward onto the DTO-type
 
 ## JSON contract
 
-`Minimal.Share/SharedConsts.JsonSerializerOptions` is the one source of truth for serialization
+`<YourApp>.Share/SharedConsts.JsonSerializerOptions` is the one source of truth for serialization
 shape — camelCase property names, nulls omitted (`DefaultIgnoreCondition.WhenWritingNull`), enums as
 camelCase strings (`JsonStringEnumConverter(JsonNamingPolicy.CamelCase)`). `ServiceConfigs.AddOptions`
 copies these settings onto ASP.NET Core's own `JsonOptions` via `ConfigureHttpJsonOptions`, so a
@@ -236,10 +244,10 @@ change to the DTO type itself.
 | Derived/computed value | Any C# expression, `AfterMapping` included | Only via a hand-written partial member + `IRegister`, and only if EF-translatable |
 | Needs `[MapsFrom]`? | Only to attach an `IRegister` customization | N/A — `[GenerateDto]` already opts in |
 
-Pick hand-written when the response should intentionally expose less than the entity, or when a
-value needs CLR-only computation (`AfterMapping`, external lookups) and will never back a generated
-list route. Pick `[GenerateDto]` when the entity already carries `[CrudCreate]`/`[CrudUpdate]` and
-the DTO doubles as the generic CRUD/list contract.
+Start at `[GenerateDto]` — always, when the entity carries `[CrudCreate]`/`[CrudUpdate]`, and by
+default otherwise too. Drop to a hand-written record only when the response must intentionally expose
+less than the entity *and* no generated route reads it, or when a value needs CLR-only computation
+(`AfterMapping`, external lookups) that will never back a generated list route.
 
 ## Common mistakes
 

package/{skills → plugin/skills}/dknet-efcore-config/SKILL.md

@@ -14,7 +14,7 @@ template — not `[RaisesEvent]`, not `[CrudCreate]`/`[CrudUpdate]`/`[CrudAction
 
 ## Mapper
 
-`Minimal.Infra/Features/ManualSample/Mappers/PurchaseOrderConfigs.cs` — the whole file:
+`<YourApp>.Infra/Features/ManualSample/Mappers/PurchaseOrderConfigs.cs` — the whole file:
 
 ```csharp
 internal sealed class PurchaseOrderConfigs : DefaultEntityTypeConfiguration<PurchaseOrder>
@@ -32,7 +32,7 @@ internal sealed class PurchaseOrderConfigs : DefaultEntityTypeConfiguration<Purc
 }
 ```
 
-`Minimal.Infra/Features/AutomatedSample/Mappers/ProductConfigs.cs` — the whole file:
+`<YourApp>.Infra/Features/AutomatedSample/Mappers/ProductConfigs.cs` — the whole file:
 
 ```csharp
 internal sealed class ProductConfigs : DefaultEntityTypeConfiguration<Product>
@@ -52,7 +52,7 @@ internal sealed class ProductConfigs : DefaultEntityTypeConfiguration<Product>
 }
 ```
 
-Location: `Minimal.Infra/Features/<Feature>/Mappers/<Entity>Configs.cs`. Discovered by
+Location: `<YourApp>.Infra/Features/<Feature>/Mappers/<Entity>Configs.cs`. Discovered by
 `UseAutoConfigModel([typeof(CoreDbContext).Assembly, typeof(Sequences).Assembly])` — an **assembly
 scan for every `IEntityTypeConfiguration<T>`**, not a Scrutor convention scan (see Infra services,
 below, for what Scrutor actually is and isn't used for here). This call is wired in **both**
@@ -103,7 +103,7 @@ configured where its owner is, not in a shared file.
 
 ## Static data seeding
 
-`Minimal.Infra/Features/ManualSample/StaticData/PurchaseOrderStaticData.cs` — the whole file:
+`<YourApp>.Infra/Features/ManualSample/StaticData/PurchaseOrderStaticData.cs` — the whole file:
 
 ```csharp
 internal sealed class PurchaseOrderStaticData : DataSeedingConfiguration<PurchaseOrder>
@@ -127,7 +127,7 @@ internal sealed class PurchaseOrderStaticData : DataSeedingConfiguration<Purchas
 }
 ```
 
-Location: `Minimal.Infra/Features/<Feature>/StaticData/<Entity>StaticData.cs`. Inherit the
+Location: `<YourApp>.Infra/Features/<Feature>/StaticData/<Entity>StaticData.cs`. Inherit the
 **base class** `DataSeedingConfiguration<T>` (`DKNet.EfCore.Extensions.Configurations`) — not an
 `IDataSeedingConfiguration<T>` interface. Override the `protected` `GetDataAsync(CancellationToken)`
 and return the fixed rows via the entity's `internal` rehydration constructor (known `Guid`s,
@@ -149,9 +149,9 @@ first seeded.
 for every `IDataSeedingConfiguration` implementer by assembly scan (same style as
 `UseAutoConfigModel`, not Scrutor) and must be called in **both**:
 
-- `Minimal.Infra/Extensions/InfraSetup.cs` → `AddInfraServices` (the DI-registered `CoreDbContext`
+- `<YourApp>.Infra/Extensions/InfraSetup.cs` → `AddInfraServices` (the DI-registered `CoreDbContext`
   the running app uses)
-- `Minimal.Infra/Extensions/InfraMigration.cs` → `MigrateDb` (a **separate** `CoreDbContext` built
+- `<YourApp>.Infra/Extensions/InfraMigration.cs` → `MigrateDb` (a **separate** `CoreDbContext` built
   for the startup-migration path; seeding runs as part of `db.Database.MigrateAsync()`)
 
 This is a real bug the template hit once already: `PurchaseOrderStaticData` was correctly discovered
@@ -159,22 +159,22 @@ by the DI-path context but the migration path built its own context without the
 `.UseAutoDataSeeding(...)` call, so seed rows never appeared in a real database even though the
 migration itself ran. When adding new seed data, verify both call sites, not just one.
 
-**No test fixture wires this.** Neither `Minimal.App.Tests`' `ApiFixture` nor
-`Minimal.App.BDDTests`' `BddApiFactory` calls `.UseAutoDataSeeding(...)` on their in-memory
+**No test fixture wires this.** Neither `<YourApp>.App.Tests`' `ApiFixture` nor
+`<YourApp>.App.BDDTests`' `BddApiFactory` calls `.UseAutoDataSeeding(...)` on their in-memory
 `DbContext` — that wiring exists only in the two real composition-root call sites above. Tests that
 actually exercise seeded data:
 
-- `Minimal.App.Tests/Unit/ManualSample/PurchaseOrderStaticDataTests.cs` — invokes the `protected
+- `<YourApp>.App.Tests/Unit/ManualSample/PurchaseOrderStaticDataTests.cs` — invokes the `protected
   GetDataAsync` via reflection (nothing public exposes it for a direct call) and asserts the three
   fixed rows, owned by `SharedConsts.SystemAccount`, with distinct `Id`s.
-- `Minimal.App.Tests/Integration/ManualSample/V1/InfraMigrationSeedingTests.cs` — runs
+- `<YourApp>.App.Tests/Integration/ManualSample/V1/InfraMigrationSeedingTests.cs` — runs
   `InfraMigration.MigrateDb` itself against a real, ephemeral Postgres `Testcontainers` instance,
   then reads `/v1/purchase-orders` over HTTP. This is the one test that fails if
   `.UseAutoDataSeeding(...)` is ever removed from `InfraMigration.MigrateDb`.
 
 ## `CoreDbContext`
 
-`Minimal.Infra/Contexts/CoreDbContext.cs` — `internal class CoreDbContext(DbContextOptions options,
+`<YourApp>.Infra/Contexts/CoreDbContext.cs` — `internal class CoreDbContext(DbContextOptions options,
 IEnumerable<IDataOwnerProvider>? dataKeyProviders = null) : DbContext(options), IDataOwnerDbContext`.
 No `DbSet<T>` declarations anywhere — the model is built entirely from the `IEntityTypeConfiguration<T>`
 scan. It exposes `AccessibleKeys` from the first registered `IDataOwnerProvider`
@@ -235,7 +235,7 @@ internal static DbContextOptionsBuilder UseNpgsqlWithMigration(
         .UseQuerySplittingBehavior(QuerySplittingBehavior.SplitQuery));
 ```
 
-`Minimal.Infra/Extensions/InfraMigration.cs` — the startup-migration path, in full:
+`<YourApp>.Infra/Extensions/InfraMigration.cs` — the startup-migration path, in full:
 
 ```csharp
 public static async Task MigrateDb(string connectionString)
@@ -253,7 +253,7 @@ public static async Task MigrateDb(string connectionString)
 ```
 
 `AddSpecRepo<CoreDbContext>()` wires `IRepositorySpec` (see `dknet-queries-specs`).
-`AddEventPublisher<CoreDbContext, EventPublisher>()` wires `Minimal.Infra/Services/EventPublisher.cs`
+`AddEventPublisher<CoreDbContext, EventPublisher>()` wires `<YourApp>.Infra/Services/EventPublisher.cs`
 — a `DefaultEventPublisher` override that does `bus.Publish(eventObj)` — as the sink both raise
 styles (`AddEvent`/`[RaisesEvent]`) publish through after a successful save.
 
@@ -263,28 +263,28 @@ Always from the solution's `ApiEndpoints/` directory (there is no wrapper script
 `dotnet ef` command):
 
 ```bash
-dotnet ef migrations add <Name> -c CoreDbContext -p Minimal.Infra/Minimal.Infra.csproj
-dotnet ef migrations remove -c CoreDbContext -p Minimal.Infra/Minimal.Infra.csproj
+dotnet ef migrations add <Name> -c CoreDbContext -p <YourApp>.Infra/<YourApp>.Infra.csproj
+dotnet ef migrations remove -c CoreDbContext -p <YourApp>.Infra/<YourApp>.Infra.csproj
 ```
 
-Inspect the generated migration under `Minimal.Infra/Migrations/` before continuing — confirm the
+Inspect the generated migration under `<YourApp>.Infra/Migrations/` before continuing — confirm the
 table, columns, and any index/constraint match what the mapper declares. Never edit an
 already-applied migration; add a new one instead. `Architecture/MigrationSchemaTests.cs` pins
 specific facts about the compiled model: `Product.Name` has a **unique** single-column index,
 the model declares a sequence in schema `seq` and a sequence named `Seq_Membership` (never one named
-after `Sequences.None`), the provider is not SQL Server, and both `Minimal.AppHost` and
-`Minimal.Infra` reference PostgreSQL/Npgsql packages, never SQL Server ones. At application start,
+after `Sequences.None`), the provider is not SQL Server, and both `<YourApp>.AppHost` and
+`<YourApp>.Infra` reference PostgreSQL/Npgsql packages, never SQL Server ones. At application start,
 `FeatureManagement:RunDbMigrationWhenAppStart` (or the `migration` launch argument — `dotnet run
---project ApiEndpoints/Minimal.Api -- migration`) is what actually calls this path; removing a
+--project ApiEndpoints/<YourApp>.Api -- migration`) is what actually calls this path; removing a
 feature's tables is a **drop migration**, covered by `dknet-feature-lifecycle`, not here.
 
 ## Infra domain services
 
-`Minimal.Domains/Services/` holds the interface, `Minimal.Infra/Services/` the implementation,
+`<YourApp>.Domains/Services/` holds the interface, `<YourApp>.Infra/Services/` the implementation,
 `InfraSetup.AddInfraServices` the registration — **by explicit `AddScoped<TInterface,
 TImplementation>()`, one line per service.** There is no Scrutor convention scan anywhere in this
-template's `Minimal.Infra` registration path — the only `Scan(` call in the whole solution is
-Mapster's `TypeAdapterConfig.Scan` in `Minimal.AppServices/Extensions/MapsToExtensions.cs`, unrelated
+template's `<YourApp>.Infra` registration path — the only `Scan(` call in the whole solution is
+Mapster's `TypeAdapterConfig.Scan` in `<YourApp>.AppServices/Extensions/MapsToExtensions.cs`, unrelated
 to service registration. Do not rely on a naming convention or namespace
 (`.Services`/`.Repos`) to get a service registered — add the `AddScoped` line yourself. `internal
 sealed` is still required by the same architecture rule that covers mappers/handlers/validators
@@ -294,7 +294,7 @@ implementation like `MembershipService` isn't targeted by that rule either, but
 `internal sealed` convention regardless).
 
 ```csharp
-// Minimal.Infra/Services/SequenceService.cs — internal abstract base, one per sequence-backed service
+// <YourApp>.Infra/Services/SequenceService.cs — internal abstract base, one per sequence-backed service
 internal abstract class SequenceService(DbContext dbContext, Sequences sequence) : ISequenceServices
 {
     public virtual async ValueTask<string> NextValueAsync() =>
@@ -303,7 +303,7 @@ internal abstract class SequenceService(DbContext dbContext, Sequences sequence)
             : Guid.NewGuid().ToString();
 }
 
-// Minimal.Infra/Services/MembershipService.cs — the whole file
+// <YourApp>.Infra/Services/MembershipService.cs — the whole file
 internal sealed class MembershipService(CoreDbContext dbContext)
     : SequenceService(dbContext, Sequences.Membership), IMembershipService;
 ```
@@ -311,19 +311,19 @@ internal sealed class MembershipService(CoreDbContext dbContext)
 `NextValueAsync()` formats the next value with the sequence's `FormatString` on PostgreSQL
 (`NextSeqValueWithFormat`), and falls back to a plain `Guid` when the context isn't Npgsql — so a
 unit test against an in-memory/SQLite context never needs a real Postgres sequence. Add your own
-service the same way: an interface in `Minimal.Domains/Services/`, an `internal sealed`
-implementation in `Minimal.Infra/Services/`, one `AddScoped` line in `AddInfraServices`.
+service the same way: an interface in `<YourApp>.Domains/Services/`, an `internal sealed`
+implementation in `<YourApp>.Infra/Services/`, one `AddScoped` line in `AddInfraServices`.
 
-## Architecture tests constraining `Minimal.Infra`
+## Architecture tests constraining `<YourApp>.Infra`
 
 `Architecture/InfraTests.cs`:
 
 - `AllEfConfigClassesShouldBeInternalAndSealed` — every `IEntityTypeConfiguration<T>` implementer.
 - `AllSeedingDataClassesShouldBeInternalAndSealed` — every `IDataSeedingConfiguration` implementer.
 - `AllHandlerClassesShouldBeInternalAndSealed` — every `IRequestHandler<>`/`IRequestHandler<,>`/
-  `IConsumer<>` implementer (covers `Minimal.Infra/Features/*/ExternalEvents/*` consumers).
+  `IConsumer<>` implementer (covers `<YourApp>.Infra/Features/*/ExternalEvents/*` consumers).
 - `AllValidatorClassesShouldBeInternalAndSealed` — every `AbstractValidator<T>` subclass found in
-  `Minimal.Infra` (none shipped there today; validators live in `Minimal.AppServices`).
+  `<YourApp>.Infra` (none shipped there today; validators live in `<YourApp>.AppServices`).
 - `AllEnumProperties_StoringToDb_ShouldHaveStringConversion` — every enum property in the built
   model must have `ProviderClrType == typeof(string)`.
 - `NoEntityString_ShouldBe_ConfiguredAs_Max` — every mapped `string` property must have an explicit
@@ -334,34 +334,34 @@ implementation in `Minimal.Infra/Services/`, one `AddScoped` line in `AddInfraSe
 
 ## Step-by-step
 
-1. Create `Minimal.Infra/Features/<Feature>/Mappers/<Entity>Configs.cs`: `internal sealed class
+1. Create `<YourApp>.Infra/Features/<Feature>/Mappers/<Entity>Configs.cs`: `internal sealed class
    <Entity>Configs : DefaultEntityTypeConfiguration<Entity>`, call `base.Configure(builder)` first,
    then indexes, `HasMaxLength`/`HasPrecision` on every column, `HasConversion<string>()` on every
    enum, `ToTable("<Plural>", "<schema>")`.
-2. If the feature needs reference data, create `Minimal.Infra/Features/<Feature>/StaticData/<Entity>StaticData.cs`:
+2. If the feature needs reference data, create `<YourApp>.Infra/Features/<Feature>/StaticData/<Entity>StaticData.cs`:
    `internal sealed class <Entity>StaticData : DataSeedingConfiguration<Entity>`, override
    `GetDataAsync`, build rows via the entity's `internal` rehydration constructor with fixed `Guid`s
    and `SharedConsts.SystemAccount`.
-3. If the feature needs a new domain service, add the interface under `Minimal.Domains/Services/`,
-   an `internal sealed` implementation under `Minimal.Infra/Services/`, and one `AddScoped<...>()`
+3. If the feature needs a new domain service, add the interface under `<YourApp>.Domains/Services/`,
+   an `internal sealed` implementation under `<YourApp>.Infra/Services/`, and one `AddScoped<...>()`
    line in `InfraSetup.AddInfraServices`.
 4. Generate and inspect the migration from `ApiEndpoints/`:
-   `dotnet ef migrations add <Name> -c CoreDbContext -p Minimal.Infra/Minimal.Infra.csproj`.
+   `dotnet ef migrations add <Name> -c CoreDbContext -p <YourApp>.Infra/<YourApp>.Infra.csproj`.
 5. `dotnet build -c Release` and `dotnet test --settings coverage.runsettings` from the solution
    root.
 
 ## Validation checklist
 
 - [ ] Mapper inherits `DefaultEntityTypeConfiguration<TEntity>` and calls `base.Configure(builder)` first
-- [ ] Mapper class is `internal sealed`, under `Minimal.Infra/Features/<Feature>/Mappers/`
+- [ ] Mapper class is `internal sealed`, under `<YourApp>.Infra/Features/<Feature>/Mappers/`
 - [ ] Every mapped `string` has an explicit `HasMaxLength`; every mapped enum has `HasConversion<string>()`
 - [ ] A real business uniqueness needs `.IsUnique()` on the index, not just a validator check
 - [ ] `ToTable("Name", "schema")` set — literal string or a `DomainSchemas` constant
 - [ ] If seeding: class is `internal sealed`, extends `DataSeedingConfiguration<T>` (not an
       interface), uses the entity's rehydration constructor, and `UseAutoDataSeeding(...)` is
       present in **both** `InfraSetup.AddInfraServices` and `InfraMigration.MigrateDb`
-- [ ] If adding a domain service: interface in `Minimal.Domains/Services/`, `internal sealed`
-      implementation in `Minimal.Infra/Services/`, explicit `AddScoped<...>()` line added — no
+- [ ] If adding a domain service: interface in `<YourApp>.Domains/Services/`, `internal sealed`
+      implementation in `<YourApp>.Infra/Services/`, explicit `AddScoped<...>()` line added — no
       convention scan will pick it up on its own
 - [ ] Migration generated from `ApiEndpoints/` and inspected before continuing
 - [ ] `dotnet build -c Release` passes