@drunkcoding/dknet-implementation-skills 0.1.0 → 14.1.1

package/{skills → plugin/skills}/dknet-feature-lifecycle/SKILL.md

@@ -24,32 +24,38 @@ behavior — which is exactly the confusion this section exists to prevent.
 
 ### At a glance: which one should I copy?
 
-**Copy `manual` (mirror `PurchaseOrder`)** when the feature needs any of:
+**Default to `auto` (mirror `Product`).** Declare the operation on the entity —
+`[CrudCreate]`/`[CrudUpdate]`/`[CrudAction]`/`[RaisesEvent]`/`[GenerateDto]` — and let
+`DKNet.SlimBus.Generators` emit the request, handler and route. Start here for every new aggregate
+and only step down when one of the reasons below actually applies to the feature in front of you.
 
-- Idempotent writes — safe client retries on `POST`.
+**Step down to `manual` (mirror `PurchaseOrder`)** when the feature needs any of:
+
+- Idempotent writes — safe client retries on `POST`. The generated create route has no
+  `.RequiredIdempotentKey()` and none can be added to it.
 - An attribute-declared (`DataAnnotations`) rule that must actually return `400`, not just be
-  present on the generated request.
+  present on the generated request (see the gap below) — and that cannot be re-expressed as a
+  FluentValidation rule.
 - An operation that writes more than one aggregate in one transaction.
 - A filtered or customized list/get query beyond the generic list route's `filter`/`search`/`orderBy`
   contract.
 - The acting user must come from a claim on the request itself (`[FromClaim]`).
 
-**Copy `auto` (mirror `Product`)** only when the aggregate is genuinely plain CRUD:
-
-- Create/update/delete carry no rule a `[Required]`/`[StringLength]`/`[Range]` can't express — and
-  you accept those attributes are forwarded but never enforced on a generated route (see the gap
-  below).
-- No idempotency requirement on create.
-- The DTO can be every audited property, narrowed at most with `Exclude`/`Include`.
-- Any extra operations fit `[CrudAction]`'s shape (mutate, return `200` + DTO) or can be excluded and
-  hand-written when they can't.
-
-A rule that must **refuse** an operation is *not* by itself a reason to choose `manual`. A
-FluentValidation validator written against a generated request still runs — `UseEndpointConfigs`
-applies `AddFluentValidationAutoValidation()` to every endpoint group, generated routes included —
-so it can read stored data through `IRepositorySpec` and refuse before the generated handler runs.
-`Product` ships two such rules (`CreateProductRequestValidator`, `DeleteProductRequestValidator`),
-both answering `409` via a `PreconditionCodes`-prefixed error code.
+None of these apply? Then `auto` is the answer, even for an aggregate with real business rules.
+Specifically, **none of the following is a reason to hand-write**:
+
+- **A rule that must refuse an operation.** A FluentValidation validator written against a generated
+  request still runs — `UseEndpointConfigs` applies `AddFluentValidationAutoValidation()` to every
+  endpoint group, generated routes included — so it can read stored data through `IRepositorySpec`
+  and refuse before the generated handler runs. `Product` ships two such rules
+  (`CreateProductRequestValidator`, `DeleteProductRequestValidator`), both answering `409` via a
+  `PreconditionCodes`-prefixed error code.
+- **A DTO that must hide fields.** `[GenerateDto(..., Exclude = [...])]` narrows the shape, and
+  `[SensitiveData]` travels from the entity onto the generated DTO.
+- **A derived response value.** A Mapster `IRegister` reaches the generated route's response with no
+  endpoint change (`ProductDto.GrossMargin`).
+- **A domain event.** `[RaisesEvent]` raises it from the save hook; the consumer is hand-written
+  either way.
 
 | Trade-off | `manual` | `auto` |
 |---|---|---|
@@ -75,20 +81,20 @@ against the real tree under both sample features.
 
 | # | Path | `manual` | `auto` |
 |---|---|---|---|
-| 1 | `Minimal.Domains/Features/<Feature>/Entities/` | entity + hand-written event record(s) | entity only — `[RaisesEvent]`/`[CrudCreate]`/`[CrudUpdate]`/`[CrudAction]` carry the rest |
-| 2 | `Minimal.Infra/Features/<Feature>/Mappers/` | `IEntityTypeConfiguration<T>` | same — **no generator produces this** |
-| 3 | `Minimal.Infra/Features/<Feature>/StaticData/` | optional `DataSeedingConfiguration<T>` | optional (neither sample ships one for `Product`) |
-| 4 | `Minimal.Infra/Features/<Feature>/ExternalEvents/` | not used by `PurchaseOrder` | optional broker consumer (`ProductCreatedNotificationHandler`) |
-| 5 | `Minimal.AppServices/<Feature>/V1/Actions/` | command requests + handlers | only operations excluded from the generated map (e.g. `Discontinue.cs`) |
-| 6 | `Minimal.AppServices/<Feature>/V1/Queries/` | hand-written read requests + handlers | custom read shapes the generic list can't express (e.g. a price-summary query) |
-| 7 | `Minimal.AppServices/<Feature>/V1/Specs/` | `Specification<T>` filters | specs backing a validator or an excluded query |
-| 8 | `Minimal.AppServices/<Feature>/V1/Events/` | domain event consumers | domain event consumers only — the generator raises, it does not consume |
-| 9 | `Minimal.AppServices/<Feature>/V1/Validators/` | not needed — validation is enforced on literal routes | validators against a **generated** request that must refuse (`CreateXRequestValidator`, `DeleteXRequestValidator`) |
-| 10 | `Minimal.AppServices/<Feature>/V1/<Feature>Dto.cs` (+ optional `<Feature>MappingRegister.cs`) | hand-written DTO record | one `[GenerateDto(typeof(Entity))] public sealed partial record` line; a Mapster `IRegister` only if a response value needs deriving from more than one column |
-| 11 | `Minimal.Api/ApiEndpoints/<Feature>/<Entity>V1Endpoint.cs` | every route a literal `Map*` call | one `group.Map<Entity>Crud(o => …)` call, plus any excluded route mapped literally below it |
-| 12 | `Minimal.App.Tests/Unit/<Feature>/` | entity/validator/spec tests | entity/handler tests |
-| 13 | `Minimal.App.Tests/Integration/<Feature>/V1/` | result-level handler + security tests | same |
-| 14 | `Minimal.App.BDDTests/Features/<Plural>/` | `*.feature` + `Steps/*.cs` | same |
+| 1 | `<YourApp>.Domains/Features/<Feature>/Entities/` | entity + hand-written event record(s) | entity only — `[RaisesEvent]`/`[CrudCreate]`/`[CrudUpdate]`/`[CrudAction]` carry the rest |
+| 2 | `<YourApp>.Infra/Features/<Feature>/Mappers/` | `IEntityTypeConfiguration<T>` | same — **no generator produces this** |
+| 3 | `<YourApp>.Infra/Features/<Feature>/StaticData/` | optional `DataSeedingConfiguration<T>` | optional (neither sample ships one for `Product`) |
+| 4 | `<YourApp>.Infra/Features/<Feature>/ExternalEvents/` | not used by `PurchaseOrder` | optional broker consumer (`ProductCreatedNotificationHandler`) |
+| 5 | `<YourApp>.AppServices/<Feature>/V1/Actions/` | command requests + handlers | only operations excluded from the generated map (e.g. `Discontinue.cs`) |
+| 6 | `<YourApp>.AppServices/<Feature>/V1/Queries/` | hand-written read requests + handlers | custom read shapes the generic list can't express (e.g. a price-summary query) |
+| 7 | `<YourApp>.AppServices/<Feature>/V1/Specs/` | `Specification<T>` filters | specs backing a validator or an excluded query |
+| 8 | `<YourApp>.AppServices/<Feature>/V1/Events/` | domain event consumers | domain event consumers only — the generator raises, it does not consume |
+| 9 | `<YourApp>.AppServices/<Feature>/V1/Validators/` | not needed — validation is enforced on literal routes | validators against a **generated** request that must refuse (`CreateXRequestValidator`, `DeleteXRequestValidator`) |
+| 10 | `<YourApp>.AppServices/<Feature>/V1/<Feature>Dto.cs` (+ optional `<Feature>MappingRegister.cs`) | hand-written DTO record | one `[GenerateDto(typeof(Entity))] public sealed partial record` line; a Mapster `IRegister` only if a response value needs deriving from more than one column |
+| 11 | `<YourApp>.Api/ApiEndpoints/<Feature>/<Entity>V1Endpoint.cs` | every route a literal `Map*` call | one `group.Map<Entity>Crud(o => …)` call, plus any excluded route mapped literally below it |
+| 12 | `<YourApp>.App.Tests/Unit/<Feature>/` | entity/validator/spec tests | entity/handler tests |
+| 13 | `<YourApp>.App.Tests/Integration/<Feature>/V1/` | result-level handler + security tests | same |
+| 14 | `<YourApp>.App.BDDTests/Features/<Plural>/` | `*.feature` + `Steps/*.cs` | same |
 
 Generated code for `auto` lands in `obj/Generated/DKNet.SlimBus.Generators/` (requests, handlers,
 route registration) and `obj/Generated/DKNet.EfCore.DtoGenerator/` (the DTO's generated members) —
@@ -101,18 +107,18 @@ the reason a feature delete is a command and not an `rm -rf`.
 
 | Touchpoint | File | When it applies |
 |---|---|---|
-| Schema constant | `Minimal.Domains/Share/DomainSchemas.cs` | if the feature added its own `const string` (the samples instead use literal schema strings — `"manual_sample"`/`"sample"` — directly in their mapper's `ToTable` call) |
-| Broker topology | `Minimal.Infra/Extensions/ServiceBusSetup.cs` | the `azb.Produce<T>`/`azb.Consume<T>` pair, e.g. `ProductCreatedEvent` on `product-tp`/`product-sub` |
-| Feature flag | `Minimal.Share/Options/FeatureOptions.cs` + `FeatureManagement` section in every `appsettings*.json` | if the feature gated itself behind a flag |
+| Schema constant | `<YourApp>.Domains/Share/DomainSchemas.cs` | if the feature added its own `const string` (the samples instead use literal schema strings — `"manual_sample"`/`"sample"` — directly in their mapper's `ToTable` call) |
+| Broker topology | `<YourApp>.Infra/Extensions/ServiceBusSetup.cs` | the `azb.Produce<T>`/`azb.Consume<T>` pair, e.g. `ProductCreatedEvent` on `product-tp`/`product-sub` |
+| Feature flag | `<YourApp>.Share/Options/FeatureOptions.cs` + `FeatureManagement` section in every `appsettings*.json` | if the feature gated itself behind a flag |
 | Auth scopes | the feature's own scopes class (e.g. `ProductScopes`) + its `foreach` registration in `Configs/Auth/AuthConfig.cs` | if the feature registered per-route scope policies |
-| Precondition codes | `Minimal.AppServices/Share/PreconditionCodes.cs` | if a validator added a `precondition.`-prefixed code for this feature |
-| Test-support visibility | `InternalsVisibleTo` in the owning project's `.csproj` (e.g. `Minimal.Api.csproj` grants `Minimal.App.TestSupport` and `Minimal.App.Tests` visibility onto `internal` scope classes) | if the feature's `internal` types need to be visible to test doubles |
-| EF migration | `Minimal.Infra/Migrations/` | see §4 — never hand-delete an applied migration |
+| Precondition codes | `<YourApp>.AppServices/Share/PreconditionCodes.cs` | if a validator added a `precondition.`-prefixed code for this feature |
+| Test-support visibility | `InternalsVisibleTo` in the owning project's `.csproj` (e.g. `<YourApp>.Api.csproj` grants `<YourApp>.App.TestSupport` and `<YourApp>.App.Tests` visibility onto `internal` scope classes) | if the feature's `internal` types need to be visible to test doubles |
+| EF migration | `<YourApp>.Infra/Migrations/` | see §4 — never hand-delete an applied migration |
 
 Enumerate existing features at any time — no registry file to keep in sync:
 
 ```bash
-ls ApiEndpoints/Minimal.Domains/Features/
+ls ApiEndpoints/<YourApp>.Domains/Features/
 ```
 
 ## 4. Migration rules on removal
@@ -120,11 +126,11 @@ ls ApiEndpoints/Minimal.Domains/Features/
 The tables outlive the code. Decide by whether the feature's migration has been applied anywhere:
 
 - **Not applied and it is the newest migration** —
-  `dotnet ef migrations remove -c CoreDbContext -p Minimal.Infra/Minimal.Infra.csproj` (run from
+  `dotnet ef migrations remove -c CoreDbContext -p <YourApp>.Infra/<YourApp>.Infra.csproj` (run from
   `ApiEndpoints/`).
 - **Applied, or newer migrations sit on top of it** — do NOT touch the old migration. Delete the
   entity and mapper, then
-  `dotnet ef migrations add Drop<Feature> -c CoreDbContext -p Minimal.Infra/Minimal.Infra.csproj`
+  `dotnet ef migrations add Drop<Feature> -c CoreDbContext -p <YourApp>.Infra/<YourApp>.Infra.csproj`
   and let EF emit the drop. Rewriting applied history corrupts `__EFMigrationsHistory` for every
   environment already running it.
 

package/{skills → plugin/skills}/dknet-feature-remove/SKILL.md

@@ -16,12 +16,12 @@ and the database tables all live outside the feature folders.
 ## Inputs
 
 `$ARGUMENTS` — the feature folder name (PascalCase, as it appears under
-`Minimal.Domains/Features/`), plus optional `--dry-run`.
+`<YourApp>.Domains/Features/`), plus optional `--dry-run`.
 
 If no feature is named, list the candidates and stop:
 
 ```bash
-ls ApiEndpoints/Minimal.Domains/Features/
+ls ApiEndpoints/<YourApp>.Domains/Features/
 ```
 
 ## Required reading
@@ -32,7 +32,7 @@ ls ApiEndpoints/Minimal.Domains/Features/
 
 ## Phase 0 — Confirm and inventory (always, even under `--dry-run`)
 
-1. Resolve the feature: confirm `ApiEndpoints/Minimal.Domains/Features/<Feature>/` exists. If it
+1. Resolve the feature: confirm `ApiEndpoints/<YourApp>.Domains/Features/<Feature>/` exists. If it
    does not, list the candidates and STOP — do not guess at a near-match.
 2. Inventory every path that will be deleted, using the §2 footprint. Report actual matches only:
    ```bash
@@ -58,24 +58,24 @@ Do NOT reorder. Each step removes only things that nothing later in the list dep
 intermediate build failure points at real coupling rather than at the ordering.
 
 1. Docs — `docs/features/<slug>/` (or wherever the solution keeps feature docs).
-2. BDD — `ApiEndpoints/Minimal.App.BDDTests/Features/<Plural>/` (both `*.feature` and the
+2. BDD — `ApiEndpoints/<YourApp>.App.BDDTests/Features/<Plural>/` (both `*.feature` and the
    generated `*.feature.cs`, plus `Steps/`).
-3. Tests — `Minimal.App.Tests/Unit/<Feature>/` and `Minimal.App.Tests/Integration/<Feature>/`.
-   Also grep `Minimal.App.Tests/Architecture/` — a convention test may assert on this feature by name.
-4. Api — `Minimal.Api/ApiEndpoints/<Feature>/`.
-5. AppServices — `Minimal.AppServices/<Feature>/`.
-6. Infra — `Minimal.Infra/Features/<Feature>/`.
-7. Domains — `Minimal.Domains/Features/<Feature>/`.
+3. Tests — `<YourApp>.App.Tests/Unit/<Feature>/` and `<YourApp>.App.Tests/Integration/<Feature>/`.
+   Also grep `<YourApp>.App.Tests/Architecture/` — a convention test may assert on this feature by name.
+4. Api — `<YourApp>.Api/ApiEndpoints/<Feature>/`.
+5. AppServices — `<YourApp>.AppServices/<Feature>/`.
+6. Infra — `<YourApp>.Infra/Features/<Feature>/`.
+7. Domains — `<YourApp>.Domains/Features/<Feature>/`.
 
 ## Phase 2 — Out-of-folder touchpoints
 
 Work the §3 table. For each, edit surgically — remove the feature's lines, never the whole file:
 
-1. `Minimal.Domains/Share/DomainSchemas.cs` — drop the feature's `const string`, if it added one.
+1. `<YourApp>.Domains/Share/DomainSchemas.cs` — drop the feature's `const string`, if it added one.
    Leave `Migration` and `Profile` alone unless this feature owned one of them.
-2. `Minimal.Infra/Extensions/ServiceBusSetup.cs` — drop the matching `azb.Produce<T>` /
+2. `<YourApp>.Infra/Extensions/ServiceBusSetup.cs` — drop the matching `azb.Produce<T>` /
    `azb.Consume<T>` pair and the now-unused `using`.
-3. `Minimal.Share/Options/FeatureOptions.cs` + every `appsettings*.json` `FeatureManagement` section
+3. `<YourApp>.Share/Options/FeatureOptions.cs` + every `appsettings*.json` `FeatureManagement` section
    — drop the flag property and its JSON key together. A key with no property silently no-ops, so
    an orphan here fails no test; delete both halves or neither.
 4. Docs cross-links — the docs index page and any feature index that linked the slice.
@@ -84,8 +84,8 @@ Work the §3 table. For each, edit surgically — remove the feature's lines, ne
 
 Apply §4 of the lifecycle skill. State which branch you took and why:
 
-- Feature's migration is the newest and unapplied → `cd ApiEndpoints && dotnet ef migrations remove -c CoreDbContext -p Minimal.Infra/Minimal.Infra.csproj`
-- Otherwise → `cd ApiEndpoints && dotnet ef migrations add Drop<Feature> -c CoreDbContext -p Minimal.Infra/Minimal.Infra.csproj` and verify the generated `Up`
+- Feature's migration is the newest and unapplied → `cd ApiEndpoints && dotnet ef migrations remove -c CoreDbContext -p <YourApp>.Infra/<YourApp>.Infra.csproj`
+- Otherwise → `cd ApiEndpoints && dotnet ef migrations add Drop<Feature> -c CoreDbContext -p <YourApp>.Infra/<YourApp>.Infra.csproj` and verify the generated `Up`
   contains the expected `DropTable` calls and nothing else.
 
 Read the generated migration before moving on. A drop migration that also touches an unrelated table

package/{skills → plugin/skills}/dknet-messaging-events/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: dknet-messaging-events
-description: Explains how this template wires SlimMessageBus as its command/query/event backbone, how the two domain-event styles (manual AddEvent vs declared RaisesEvent) reach a subscriber, and how to forward an event to an external Azure Service Bus topic. Use whenever adding a domain event, wiring an internal or external event consumer, or reasoning about how a command/query travels from an endpoint to its handler.
+description: Explains how this template wires SlimMessageBus as its command/query/event backbone, how the three domain-event raise styles ([RaisesEvent], AddEvent<TEvent>(), AddEvent(instance)) reach a subscriber, and how to forward an event to an external Azure Service Bus topic. Use whenever adding a domain event, wiring an internal or external event consumer, or reasoning about how a command/query travels from an endpoint to its handler.
 ---
 
 # DKNet messaging and events (SlimMessageBus)
@@ -31,12 +31,12 @@ Handlers never call `SaveChanges`. `AddSlimBusEfCoreInterceptor<CoreDbContext>()
 successfully.
 
 **Auto-discovery, no per-message registration.** `AutoDeclareFrom(serviceAssembly)` scans the
-`Minimal.AppServices` assembly and declares every request/handler pair it finds by convention;
+`<YourApp>.AppServices` assembly and declares every request/handler pair it finds by convention;
 `AddServicesFromAssembly(serviceAssembly)` registers the discovered handler classes in DI. Adding a
 new `*Request` + `*Handler` pair needs no wiring beyond writing the two classes — see the
 `dknet-crud` skill for how requests, validators, and handlers are shaped.
 
-## Wiring: `Minimal.Infra/Extensions/ServiceBusSetup.cs`
+## Wiring: `<YourApp>.Infra/Extensions/ServiceBusSetup.cs`
 
 ```csharp
 public static IServiceCollection AddServiceBus(
@@ -89,13 +89,20 @@ header envelope or JSON round-trip. `EnableBlockingPublish = false` means `bus.P
 domain event does not wait for every subscriber to finish before returning — a slow or hung internal
 consumer does not block the HTTP response.
 
-## Domain events: two styles, same publisher
+## Domain events: three raise styles, same publisher
 
-Both styles are covered in full in the `dknet-entity` skill; here only what matters for
-messaging.
+All are covered in full in the `dknet-entity` and `dknet-ddd-principles` skills; here only what
+matters for messaging. Prefer them in this order — `[RaisesEvent]`, then `AddEvent<TEvent>()`, then
+`AddEvent(instance)`.
 
-- **Manual** — `PurchaseOrder`'s constructor calls `AddEvent(new PurchaseOrderCreatedEvent(...))` by
-  hand; the record is a plain hand-written type next to the entity.
+- **Manual, instance** — `PurchaseOrder`'s constructor calls
+  `AddEvent(new PurchaseOrderCreatedEvent(...))` by hand; the record is a plain hand-written type
+  next to the entity. Last resort: use it only when the payload is not a projection of the entity.
+- **Manual, type-only** — `AddEvent<TEvent>()` queues the event *type*; the publisher maps the
+  entity onto it via `IMapper` when the save succeeds, so there is no hand-written payload. It
+  **requires an `IMapper` registration** — without one the publisher throws `EventException` instead
+  of dropping the event. Use it when the decision to raise needs real logic but the payload does
+  not.
 - **Declared** — `Product` carries `[RaisesEvent(EventOperations.Created, Include = [...])]` and
   `[RaisesEvent(EventOperations.Updated, nameof(Price))]`; DKNet's EF Core save hook raises the event
   itself after a successful save. Composed names fold the narrowing property in:
@@ -104,7 +111,7 @@ messaging.
   property's value actually changed on that save — calling `ChangePrice` with the price it already
   holds raises nothing.
 
-Either way, the entity only **queues** the event. `Minimal.Infra/Services/EventPublisher.cs` is what
+Either way, the entity only **queues** the event. `<YourApp>.Infra/Services/EventPublisher.cs` is what
 actually calls the bus:
 
 ```csharp
@@ -128,13 +135,13 @@ a specific order across multiple handlers of the same event, and multiple consum
 allowed (both an internal and an external consumer subscribe to the same `ProductCreatedEvent`, see
 below).
 
-**Consumers are always hand-written.** Neither `[RaisesEvent]` nor `AddEvent` generates a consumer —
-only the raise side is automatic for the declared style.
+**Consumers are always hand-written.** Neither `[RaisesEvent]` nor either `AddEvent` overload
+generates a consumer — only the raise side is automatic for the declared style.
 
-Internal consumers live in `Minimal.AppServices/<Feature>/V1/Events/`:
+Internal consumers live in `<YourApp>.AppServices/<Feature>/V1/Events/`:
 
 ```csharp
-// Minimal.AppServices/ManualSample/V1/Events/PurchaseOrderCreatedEventHandler.cs
+// <YourApp>.AppServices/ManualSample/V1/Events/PurchaseOrderCreatedEventHandler.cs
 internal sealed class PurchaseOrderCreatedEventHandler(ILogger<PurchaseOrderCreatedEventHandler> logger)
     : Fluents.EventsConsumers.IHandler<PurchaseOrderCreatedEvent>
 {
@@ -152,7 +159,7 @@ internal sealed class PurchaseOrderCreatedEventHandler(ILogger<PurchaseOrderCrea
 ```
 
 ```csharp
-// Minimal.AppServices/AutomatedSample/V1/Events/ProductEventHandlers.cs
+// <YourApp>.AppServices/AutomatedSample/V1/Events/ProductEventHandlers.cs
 internal sealed class ProductCreatedEventHandler(ILogger<ProductCreatedEventHandler> logger)
     : Fluents.EventsConsumers.IHandler<ProductCreatedEvent>
 {
@@ -171,7 +178,7 @@ A second child bus, `"AzureBus"`, is added only when **both** conditions hold:
 
 | Condition | Where |
 |---|---|
-| `FeatureManagement:EnableServiceBus` is `true` | `Minimal.Share/Options/FeatureOptions.cs` |
+| `FeatureManagement:EnableServiceBus` is `true` | `<YourApp>.Share/Options/FeatureOptions.cs` |
 | `ConnectionStrings:AzureBus` is a non-empty connection string | checked in `AddServiceBus` |
 
 ```csharp
@@ -228,12 +235,12 @@ The same event type — `ProductCreatedEvent` — flows on both buses. There is
 event record. The `Produce`/`Consume` declaration in `AddAzureBus` is what forwards an
 already-declared internal event externally; nothing about the event itself changes.
 
-External consumers live in `Minimal.Infra/Features/<Feature>/ExternalEvents/`, are `internal
+External consumers live in `<YourApp>.Infra/Features/<Feature>/ExternalEvents/`, are `internal
 sealed`, and are discovered by the same `AddServicesFromAssembly(typeof(InfraSetup).Assembly)` call
 inside `AddAzureBus` — no separate registration:
 
 ```csharp
-// Minimal.Infra/Features/AutomatedSample/ExternalEvents/ProductCreatedNotificationHandler.cs
+// <YourApp>.Infra/Features/AutomatedSample/ExternalEvents/ProductCreatedNotificationHandler.cs
 internal sealed class ProductCreatedNotificationHandler(ILogger<ProductCreatedNotificationHandler> logger)
     : Fluents.EventsConsumers.IHandler<ProductCreatedEvent>
 {
@@ -259,7 +266,7 @@ internal sealed class ProductCreatedNotificationHandler(ILogger<ProductCreatedNo
        .WithConsumer<THandler>());
    ```
 2. Write `THandler` as a `Fluents.EventsConsumers.IHandler<TEvent>` under
-   `Minimal.Infra/Features/<Feature>/ExternalEvents/`. External-system concerns belong in `Infra`,
+   `<YourApp>.Infra/Features/<Feature>/ExternalEvents/`. External-system concerns belong in `Infra`,
    never `AppServices`.
 3. Nothing else — `azb.AddServicesFromAssembly(typeof(InfraSetup).Assembly)` already picks up the
    new handler by assembly scan.
@@ -274,7 +281,7 @@ azb.Consume<TExternalEvent>(o => o.Path("<their-topic-name>")
     .WithConsumer<THandler>());
 ```
 
-`THandler` still goes in `Minimal.Infra/Features/<Feature>/ExternalEvents/` and still needs no
+`THandler` still goes in `<YourApp>.Infra/Features/<Feature>/ExternalEvents/` and still needs no
 manual DI registration. Do not add a matching `azb.Produce<TExternalEvent>(...)` — that would make
 this service claim ownership of an event type it does not raise.
 
@@ -289,13 +296,13 @@ from Azure Service Bus: `ProductCreatedEvent` is still published in-memory and h
 
 ## Local development
 
-`Minimal.AppHost/AppHost.cs` (Aspire orchestration) wires only Redis and PostgreSQL today:
+`<YourApp>.AppHost/AppHost.cs` (Aspire orchestration) wires only Redis and PostgreSQL today:
 
 ```csharp
 var cache = builder.AddRedis("Redis");
 var postgres = builder.AddPostgres("Postgres");
 ...
-builder.AddProject("Api", "../Minimal.Api/Minimal.Api.csproj")
+builder.AddProject("Api", "../<YourApp>.Api/<YourApp>.Api.csproj")
     .WithReference(cache, "Redis")
     .WithReference(apDb, "AppDb")
     //.WaitFor(bus)
@@ -304,7 +311,7 @@ builder.AddProject("Api", "../Minimal.Api/Minimal.Api.csproj")
 ```
 
 The `.WaitFor(bus)` line is commented out and no `bus` resource is added above it — no Azure Service
-Bus emulator is wired into `AppHost.cs` as shipped. `Minimal.AppHost/Configs/busConfig.json` exists
+Bus emulator is wired into `AppHost.cs` as shipped. `<YourApp>.AppHost/Configs/busConfig.json` exists
 and is copied to the build output, but nothing in `AppHost.cs` references it — it's a config file
 waiting for an emulator resource, not something a consumer touches to run the app today.
 
@@ -314,7 +321,7 @@ DKNet also carries an `Aspire.Hosting.ServiceBus` project that runs the emulator
 
 ## Testing events
 
-**BDD — log-capture pattern.** `Minimal.App.TestSupport/TestLogCapture.cs` is an `ILoggerProvider`
+**BDD — log-capture pattern.** `<YourApp>.App.TestSupport/TestLogCapture.cs` is an `ILoggerProvider`
 that queues every formatted log line into an in-memory collection, registered as an additional
 provider alongside the host's normal logging. A scenario asserts on the resulting text instead of on
 internal call order:
@@ -381,15 +388,15 @@ that path as untested until you add integration coverage against a real namespac
 - **What you might expect:** an `[RaisesEvent(EventOperations.Updated, ...)]` fires on every call to
   the method that touches that property. **What actually happens:** it only fires when the value
   actually changed on that save — see `dknet-entity` for the mechanics.
-- **What you might expect:** placing a new event consumer in `Minimal.Api` gets it discovered like
-  the others. **What actually happens:** discovery only scans the `Minimal.AppServices` assembly
-  (internal) and the `Minimal.Infra` assembly (external, inside `AddAzureBus`). A consumer in
-  `Minimal.Api` is never registered.
+- **What you might expect:** placing a new event consumer in `<YourApp>.Api` gets it discovered like
+  the others. **What actually happens:** discovery only scans the `<YourApp>.AppServices` assembly
+  (internal) and the `<YourApp>.Infra` assembly (external, inside `AddAzureBus`). A consumer in
+  `<YourApp>.Api` is never registered.
 - **What you might expect:** setting `EnableServiceBus: true` is enough to start producing to Azure.
   **What actually happens:** `ConnectionStrings:AzureBus` must also be a non-empty string. Either one
   missing and the `AzureBus` child bus, and everything registered only on it, silently does not exist
   — no error, no log, just no external traffic.
 - **What you might expect:** an external consumer belongs next to the internal one, in
-  `Minimal.AppServices/<Feature>/V1/Events/`. **What actually happens:** external-system consumers
-  belong in `Minimal.Infra/Features/<Feature>/ExternalEvents/` — that is the assembly `AddAzureBus`
+  `<YourApp>.AppServices/<Feature>/V1/Events/`. **What actually happens:** external-system consumers
+  belong in `<YourApp>.Infra/Features/<Feature>/ExternalEvents/` — that is the assembly `AddAzureBus`
   scans, and it keeps the external-system dependency out of `AppServices`.

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

@@ -5,7 +5,7 @@ description: Add DKNet's Core, EF Core, messaging/CQRS, or blob-storage NuGet pa
 
 # Skill: Adopting DKNet Packages in an Existing Project
 
-This skill is for a project that already exists with its own namespaces and folder layout — it does not assume `dotnet new dknet-minimal` was run, and never references `Minimal.*` types. If you're scaffolding a brand-new solution from the template instead, use **dknet-project-structure** and the other `dknet-*` skills.
+This skill is for a project that already exists with its own namespaces and folder layout — it does not assume `dotnet new dknet-minimal` was run, and never references the template's `<YourApp>.*` types. If you're scaffolding a brand-new solution from the template instead, use **dknet-project-structure** and the other `dknet-*` skills.
 
 Each package below is independent — install only what the feature needs. All packages target **.NET 10.0+** (EF Core packages additionally need **EF Core 10.0+**); consult `Directory.Packages.props` (or your project's own central version file) before adding a version attribute per-project.
 
@@ -232,7 +232,7 @@ Swapping providers later (e.g. `.Local` in dev, `.AzureStorage` in production) o
 
 - [ ] Only the packages the feature actually needs were added (no blanket "add everything")
 - [ ] EF Core additions layer onto the existing `DbContext`/provider — no assumption of a specific database engine
-- [ ] No `Minimal.*` namespace or template folder path (`Minimal.Domains`, `Minimal.AppServices`, …) appears anywhere in the guidance followed
+- [ ] No template-generated `<YourApp>.*` namespace or template folder path (`<YourApp>.Domains`, `<YourApp>.AppServices`, …) appears anywhere in the guidance followed
 - [ ] Repositories/specs/handlers registered in DI (`AddSpecRepo`, `AddSlimBusEfCoreInterceptor`, `AddAzureStorageAdapter`, etc.) — nothing relies on auto-discovery unless the package documents it
 - [ ] For blob storage, exactly one provider package installed alongside `Abstractions`
 - [ ] `dotnet build` passes with the new package references
@@ -245,7 +245,7 @@ Swapping providers later (e.g. `.Local` in dev, `.AzureStorage` in production) o
 | Building a dynamic predicate directly against `DbContext` without `.AsExpandable()` | Required for LinqKit to translate the expression; the `IRepositorySpec` extensions already apply it |
 | Installing more than one blob storage provider package for the same `IBlobService` | Register exactly one — the last registration wins and the others are dead weight |
 | Assuming a specific EF Core provider (SQL Server, Postgres, …) is required | Every package here is provider-agnostic; it only needs a working `DbContext` |
-| Copying `Minimal.*` namespaces/paths from the template's docs | This skill — and any project using it — has its own namespaces; the template's layout doesn't apply |
+| Copying the template's `<YourApp>.*` namespaces/paths from the template's docs | This skill — and any project using it — has its own namespaces; the template's layout doesn't apply |
 
 ## Next Steps
 

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

@@ -11,7 +11,7 @@ instead — this skill only covers cross-cutting platform wiring.
 
 ## Start-up order
 
-`Minimal.Api/Program.cs`, in the order it actually runs:
+`<YourApp>.Api/Program.cs`, in the order it actually runs:
 
 ```csharp
 var builder = WebApplication.CreateBuilder(args);
@@ -114,7 +114,7 @@ registration (needed because `ConfigureHttpJsonOptions` has no service-provider
 
 ## `FeatureManagement` flags
 
-Section name is `FeatureManagement` (`FeatureOptions.Name`), bound in `Minimal.Api/Program.cs` via
+Section name is `FeatureManagement` (`FeatureOptions.Name`), bound in `<YourApp>.Api/Program.cs` via
 `GetSection(FeatureOptions.Name).Get<FeatureOptions>()`. **Every JSON key must spell a
 `FeatureOptions` property name exactly** — `Get<FeatureOptions>()` silently ignores an unknown key
 instead of failing, so a typo no-ops rather than erroring.
@@ -131,7 +131,7 @@ instead of failing, so a typo no-ops rather than erroring.
 | `EnableRateLimit` | `true` | `true` | `false` | `false` | `Configs/RateLimits/RateLimitConfig.cs` |
 | `EnableRequestBounds` | `true` | `true` | **`false`** | — | `Configs/RequestBoundsConfig.cs` |
 | `EnableSecurityHeaders` | `true` | `true` | **`false`** | — | `Configs/SecurityHeadersConfig.cs` |
-| `EnableServiceBus` | `false` | `true` | `false` | — | `Minimal.Infra/Extensions/ServiceBusSetup.cs` (Azure child bus only) |
+| `EnableServiceBus` | `false` | `true` | `false` | — | `<YourApp>.Infra/Extensions/ServiceBusSetup.cs` (Azure child bus only) |
 | `EnableSwagger` | `false` | `false` | `true` | — | `Configs/Swagger/SwaggerConfig.cs` |
 | `EnableVersioning` | `true` | `true` | — | — | `Configs/VersioningConfig.cs` |
 | `RequireAuthorization` | `false` | **`true`** | `false` | `false` | `Configs/Auth/AuthConfig.cs` |
@@ -149,7 +149,7 @@ alone does nothing — the Azure child bus is added only when the flag is `true`
 `ConnectionStrings:AzureBus` is non-empty; the in-memory child bus that carries internal
 command/event dispatch is unconditional.
 
-**Adding a flag**: add the `bool` property to `Minimal.Share/Options/FeatureOptions.cs`, add the
+**Adding a flag**: add the `bool` property to `<YourApp>.Share/Options/FeatureOptions.cs`, add the
 same-spelled key to every `appsettings*.json` that needs a non-default value, and consume it either
 as `features.YourFlag` inside `AppConfig.cs`/`ServiceConfigs.cs` (both already receive a
 `FeatureOptions features` parameter) or via `IOptions<FeatureOptions>` injected anywhere else in DI.
@@ -158,7 +158,7 @@ as `features.YourFlag` inside `AppConfig.cs`/`ServiceConfigs.cs` (both already r
 
 | Section | Keys | Shipped default | Reads |
 |---|---|---|---|
-| `ConnectionStrings` | `AppDb`, `Redis`, `AzureBus`, `AzureAppConfig` | all `""` except overlays | `AppDb` → `Minimal.Infra/Extensions/InfraSetup.cs`, `DbMigration.cs`; `Redis` → `CacheConfig.cs`, `AppConfig.cs` (idempotency store); `AzureBus` → `ServiceBusSetup.cs`; `AzureAppConfig` → `AzureAppConfigSetup.cs` |
+| `ConnectionStrings` | `AppDb`, `Redis`, `AzureBus`, `AzureAppConfig` | all `""` except overlays | `AppDb` → `<YourApp>.Infra/Extensions/InfraSetup.cs`, `DbMigration.cs`; `Redis` → `CacheConfig.cs`, `AppConfig.cs` (idempotency store); `AzureBus` → `ServiceBusSetup.cs`; `AzureAppConfig` → `AzureAppConfigSetup.cs` |
 | `Authentication:Schemes:Bearer` | `MetadataAddress`, `ValidAudiences`, `ValidIssuer` | placeholder tenant/audience | bound by ASP.NET Core's own `AddJwtBearer()`; registered only when `RequireAuthorization` is on |
 | `Cors` | `AllowedOrigins` (`[]`), `AllowedMethods` (`GET,POST,PUT,PATCH`), `AllowedHeaders` (`Authorization,Content-Type,Accept,X-Idempotency-Key`) | empty origins ⇒ CORS not wired at all | `Configs/CrosConfig.cs` |
 | `Security` | `TrustedProxies` (IP list), `TrustedNetworks` (CIDR list) | both `[]` | `Configs/ForwardedHeadersConfig.cs` — both empty ⇒ `ForwardedHeaders.None` |
@@ -167,10 +167,10 @@ as `features.YourFlag` inside `AppConfig.cs`/`ServiceConfigs.cs` (both already r
 | `RateLimit` | `DefaultRequestLimit`, `DefaultConcurrentLimit`, `TimeWindowInSeconds` | class default `2/2/1s`; base file `100/20/1s`; Development `1/1/10s` | `Configs/RateLimits/RateLimitConfig.cs` |
 | `AzureAppConfiguration` | `KeyPrefix`, `Label`, `CacheExpirationInSeconds`, `LoadFeatureFlags`, `FeatureFlagPrefix` | ships in base file | **dead** — see below |
 | `AzureAppConfig` | `ConnectionStringName` (`AzureAppConfig`), `Label` (`null`→`SharedConsts.ApiName`), `LoadFeatureFlags`, `FeatureFlagPrefix`, `RefreshIntervalInMinutes` | not shipped in base file | `Configs/AzureAppConfig/AzureAppConfigSetup.cs` — the last three properties are declared but never read; refresh is hard-coded to 30 minutes |
-| `OTEL_EXPORTER_OTLP_ENDPOINT`, `OTEL_SERVICE_NAME` | flat keys, not a section | `http://localhost:4317`; `Minimal.Api` | `Configs/LogConfigs.cs` reads only the endpoint key as a presence check; `OTEL_SERVICE_NAME` is never read by template code |
+| `OTEL_EXPORTER_OTLP_ENDPOINT`, `OTEL_SERVICE_NAME` | flat keys, not a section | `http://localhost:4317`; `<YourApp>.Api` | `Configs/LogConfigs.cs` reads only the endpoint key as a presence check; `OTEL_SERVICE_NAME` is never read by template code |
 | `AzureMonitor:ConnectionString` | — | `""` | `Configs/LogConfigs.cs` — non-blank adds `UseAzureMonitor()` |
 | `DKNet:ListQuery` | `DefaultPageSize`, `MaxPageSize`, `DefaultActivityWindowMonths` | package defaults (1000/1000/3) | consumed by the generic `MapGetList<TEntity,TKey,TDto>` route |
-| `SampleData:RecordsPerEntity` | — | `10000` | `Minimal.AppHost/appsettings.json`, read by `AppHost.cs` only — never present in the API |
+| `SampleData:RecordsPerEntity` | — | `10000` | `<YourApp>.AppHost/appsettings.json`, read by `AppHost.cs` only — never present in the API |
 
 `AzureAppConfiguration` (note the longer name) is a real trap: it ships in the base
 `appsettings.json` but binds to nothing — `AzureAppConfigOptions.Name` is `"AzureAppConfig"`, a
@@ -265,7 +265,7 @@ option nor an option's value; `JobRegistry.Jobs` maps recognized names (case-ins
 message-bus connection opened.
 
 ```bash
-dotnet run --project ApiEndpoints/Minimal.Api -- migration
+dotnet run --project ApiEndpoints/<YourApp>.Api -- migration
 ```
 
 `RunDbMigrationWhenAppStart` is the in-process alternative: same `MigrationJob.RunAsync` call, made
@@ -277,13 +277,13 @@ Keep a job as small as `MigrationJob`: it receives the builder as it stood right
 `AddLogConfig`, with no DI container built yet, so it constructs what it needs directly from
 `builder.Configuration`/`builder.Services.BuildServiceProvider()` rather than resolving from a host.
 
-## Aspire (`Minimal.AppHost`)
+## Aspire (`<YourApp>.AppHost`)
 
 `AppHost.cs` provisions `Redis` and `Postgres` (with an `AppDb` database), starts the `Api` project
-by path (`../Minimal.Api/Minimal.Api.csproj` — a literal path string, not `AddProject<T>`, so it
+by path (`../<YourApp>.Api/<YourApp>.Api.csproj` — a literal path string, not `AddProject<T>`, so it
 survives `sourceName` rewriting even for a dotted name), and calls `.WaitFor(cache).WaitFor(apDb)`.
 Azure Service Bus is **not** wired — `.WaitFor(bus)` is commented out in source; only Redis and
-PostgreSQL resources exist. `Minimal.AppHost/Configs/busConfig.json` (an Azure Service Bus emulator
+PostgreSQL resources exist. `<YourApp>.AppHost/Configs/busConfig.json` (an Azure Service Bus emulator
 topology file for the `product-tp`/`product-sub` topic) sits in the project but nothing in
 `AppHost.cs` references it — it is not currently wired to any resource.
 
@@ -297,15 +297,15 @@ role-gated filtering is visible on a freshly started host.
 
 ```bash
 # Full stack — Redis + PostgreSQL via Docker, sample data generated
-dotnet run --project ApiEndpoints/Minimal.AppHost
+dotnet run --project ApiEndpoints/<YourApp>.AppHost
 
 # API only — no containers, needs ConnectionStrings:AppDb supplied yourself
-dotnet run --project ApiEndpoints/Minimal.Api
+dotnet run --project ApiEndpoints/<YourApp>.Api
 ```
 
 ## Test hosts
 
-`Minimal.App.TestSupport/TestApiFactoryBase.cs` is the shared `WebApplicationFactory<Program>` both
+`<YourApp>.App.TestSupport/TestApiFactoryBase.cs` is the shared `WebApplicationFactory<Program>` both
 xUnit and BDD suites subclass. It always: `UseEnvironment("Testing")`; pushes
 `FeatureManagement:RunDbMigrationWhenAppStart=false`, `EnableSwagger=false`,
 `EnableAzureAppConfig=false`, `ConnectionStrings:AppDb=UseInMemory` through