@drunkcoding/dknet-implementation-skills 14.1.0 → 14.2.0

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

@@ -11,21 +11,21 @@ of this same map — read it too if you're unsure which project a file belongs i
 ## Layer boundaries and dependency direction
 
 ```
-Minimal.Api          → entry point, endpoints, auth, OpenAPI
+<YourApp>.Api          → entry point, endpoints, auth, OpenAPI
   ↓
-Minimal.AppServices  → CQRS handlers, validators, DTOs, domain event handlers
+<YourApp>.AppServices  → CQRS handlers, validators, DTOs, domain event handlers
   ↓
-Minimal.Domains      → entities, aggregate roots, domain service contracts
+<YourApp>.Domains      → entities, aggregate roots, domain service contracts
   ↑
-Minimal.Infra        → EF Core (CoreDbContext), repos, event publisher, service bus
+<YourApp>.Infra        → EF Core (CoreDbContext), repos, event publisher, service bus
   (wires into Api via InfraSetup.AddInfraServices)
 
-Minimal.Share        → shared constants/options/base types (read by all layers)
-Minimal.AppHost      → Aspire orchestration only (Redis + PostgreSQL + Minimal.Api), no business logic
+<YourApp>.Share        → shared constants/options/base types (read by all layers)
+<YourApp>.AppHost      → Aspire orchestration only (Redis + PostgreSQL + <YourApp>.Api), no business logic
 ```
 
-Every project reference points inward: `Minimal.Domains` references only `Minimal.Share`;
-`Minimal.AppServices` depends only on `Domains` (+ `Share`); `Minimal.Infra` and `Minimal.Api`
+Every project reference points inward: `<YourApp>.Domains` references only `<YourApp>.Share`;
+`<YourApp>.AppServices` depends only on `Domains` (+ `Share`); `<YourApp>.Infra` and `<YourApp>.Api`
 depend on both, never the reverse. An outward reference (`Domains` → `AppServices`, say) is a
 circular project reference MSBuild refuses outright — the compiler holds this boundary, not a test.
 
@@ -33,15 +33,15 @@ circular project reference MSBuild refuses outright — the compiler holds this
 
 | Project | Owns |
 |---|---|
-| `Minimal.Domains` | Entities, aggregate roots, owned types, domain service **contracts** (`IDomainService`) |
-| `Minimal.Infra` | EF Core mappers, seed data, repositories, `EventPublisher`, service-bus topology, domain service **implementations** |
-| `Minimal.AppServices` | Command/query requests, handlers, FluentValidation validators, specs, DTOs, domain-event consumers |
-| `Minimal.Api` | `IEndpointConfig` route groups, auth policies, platform `Configs/` |
-| `Minimal.Share` | Cross-cutting constants/options (`FeatureOptions`, `SharedConsts`) read by every layer |
-| `Minimal.AppHost` | Aspire orchestration (Redis, PostgreSQL, sample-data generation) — no business logic |
-
-`Minimal.App.Tests` (xUnit + Shouldly), `Minimal.App.BDDTests` (Reqnroll + NUnit) and
-`Minimal.App.TestSupport` (shared `WebApplicationFactory` base) round out the solution but carry no
+| `<YourApp>.Domains` | Entities, aggregate roots, owned types, domain service **contracts** (`IDomainService`) |
+| `<YourApp>.Infra` | EF Core mappers, seed data, repositories, `EventPublisher`, service-bus topology, domain service **implementations** |
+| `<YourApp>.AppServices` | Command/query requests, handlers, FluentValidation validators, specs, DTOs, domain-event consumers |
+| `<YourApp>.Api` | `IEndpointConfig` route groups, auth policies, platform `Configs/` |
+| `<YourApp>.Share` | Cross-cutting constants/options (`FeatureOptions`, `SharedConsts`) read by every layer |
+| `<YourApp>.AppHost` | Aspire orchestration (Redis, PostgreSQL, sample-data generation) — no business logic |
+
+`<YourApp>.App.Tests` (xUnit + Shouldly), `<YourApp>.App.BDDTests` (Reqnroll + NUnit) and
+`<YourApp>.App.TestSupport` (shared `WebApplicationFactory` base) round out the solution but carry no
 feature code of their own.
 
 ## Vertical-slice folder footprint for one feature
@@ -51,12 +51,12 @@ the two shipped samples, `ManualSample` and `AutomatedSample`, under `ApiEndpoin
 
 | Layer | `mode=manual` | `mode=auto` |
 |---|---|---|
-| Domains | `Minimal.Domains/Features/<Feature>/Entities/` — hand-written mutation + `AddEvent(...)` | same path — class-level `[RaisesEvent]`, `[CrudCreate]` ctor, `[CrudUpdate]`/`[CrudAction]` methods |
-| Infra | `Minimal.Infra/Features/<Feature>/Mappers/` (`IEntityTypeConfiguration<T>`), optional `StaticData/` (seed data) | same `Mappers/` (still hand-written — no generator produces it), optional `ExternalEvents/` (broker consumers) |
-| AppServices | `Minimal.AppServices/<Feature>/V1/Actions/`, `Queries/`, `Specs/`, `Events/`, `<Feature>Dto.cs` | `Minimal.AppServices/<Feature>/V1/<Feature>Dto.cs` (one `[GenerateDto]` line), `Events/` (consumers only — generator raises, doesn't consume), plus optional `Validators/` (precondition rules against a generated request), `Actions/` (any operation dropped out of the generated map), `Queries/`/`Specs/` (custom read shapes), and a Mapster `IRegister` for any hand-added DTO property |
-| Api | `Minimal.Api/ApiEndpoints/<Feature>/<Entity>V1Endpoint.cs` — every route a literal `Map*` call | same file — one `group.Map<Entity>Crud(o => …)` call, plus any routes excluded from it mapped literally below |
-| Tests | `Minimal.App.Tests/Unit/<Feature>/`, `Minimal.App.Tests/Integration/<Feature>/V1/` | same |
-| BDD | `Minimal.App.BDDTests/Features/<Plural>/*.feature` + `Steps/*.cs` | same |
+| Domains | `<YourApp>.Domains/Features/<Feature>/Entities/` — hand-written mutation + `AddEvent(...)` | same path — class-level `[RaisesEvent]`, `[CrudCreate]` ctor, `[CrudUpdate]`/`[CrudAction]` methods |
+| Infra | `<YourApp>.Infra/Features/<Feature>/Mappers/` (`IEntityTypeConfiguration<T>`), optional `StaticData/` (seed data) | same `Mappers/` (still hand-written — no generator produces it), optional `ExternalEvents/` (broker consumers) |
+| AppServices | `<YourApp>.AppServices/<Feature>/V1/Actions/`, `Queries/`, `Specs/`, `Events/`, `<Feature>Dto.cs` | `<YourApp>.AppServices/<Feature>/V1/<Feature>Dto.cs` (one `[GenerateDto]` line), `Events/` (consumers only — generator raises, doesn't consume), plus optional `Validators/` (precondition rules against a generated request), `Actions/` (any operation dropped out of the generated map), `Queries/`/`Specs/` (custom read shapes), and a Mapster `IRegister` for any hand-added DTO property |
+| Api | `<YourApp>.Api/ApiEndpoints/<Feature>/<Entity>V1Endpoint.cs` — every route a literal `Map*` call | same file — one `group.Map<Entity>Crud(o => …)` call, plus any routes excluded from it mapped literally below |
+| Tests | `<YourApp>.App.Tests/Unit/<Feature>/`, `<YourApp>.App.Tests/Integration/<Feature>/V1/` | same |
+| BDD | `<YourApp>.App.BDDTests/Features/<Plural>/*.feature` + `Steps/*.cs` | same |
 
 The domain/AppServices feature folder name doesn't have to match the BDD folder's plural — the two
 samples happen to (`ManualSample`↔`PurchaseOrders`, `AutomatedSample`↔`Products`).
@@ -65,16 +65,16 @@ samples happen to (`ManualSample`↔`PurchaseOrders`, `AutomatedSample`↔`Produ
 
 | What | Found by | Scans |
 |---|---|---|
-| HTTP route group | `IEndpointConfig` | `UseEndpointConfigs`, assembly scan of `Minimal.Api` |
-| Command/query request+handler | `Fluents.Requests.*`/`Fluents.Queries.*` | `AutoDeclareFrom`/`AddServicesFromAssembly` on the in-memory bus, scanning `Minimal.AppServices` |
+| HTTP route group | `IEndpointConfig` | `UseEndpointConfigs`, assembly scan of `<YourApp>.Api` |
+| Command/query request+handler | `Fluents.Requests.*`/`Fluents.Queries.*` | `AutoDeclareFrom`/`AddServicesFromAssembly` on the in-memory bus, scanning `<YourApp>.AppServices` |
 | Request validator | `AbstractValidator<TRequest>` | `AddValidatorsFromAssembly(typeof(AppSetup).Assembly, includeInternalTypes: true)` |
 | EF Core table mapping | `IEntityTypeConfiguration<T>` | `UseAutoConfigModel([...])` — must be wired in **both** `InfraSetup.AddInfraServices` and `InfraMigration.MigrateDb` |
 | Seed data | `DataSeedingConfiguration<T>` (base class, not an interface) | `UseAutoDataSeeding([...])` — same both-places rule; wiring only one is a real bug this template hit once |
-| Repos/domain services | — (not auto-discovered) | Explicit `AddScoped<IService, Service>()` line in `InfraSetup.AddInfraServices`; keep implementations `internal sealed` under `Minimal.Infra/Services/` |
-| DTO mapping | `[MapsFrom(typeof(Entity))]` or `[GenerateDto(typeof(Entity))]` | Mapster `ScanMaps()` in `Minimal.AppServices/AppSetup.cs` |
+| Repos/domain services | — (not auto-discovered) | Explicit `AddScoped<IService, Service>()` line in `InfraSetup.AddInfraServices`; keep implementations `internal sealed` under `<YourApp>.Infra/Services/` |
+| DTO mapping | `[MapsFrom(typeof(Entity))]` or `[GenerateDto(typeof(Entity))]` | Mapster `ScanMaps()` in `<YourApp>.AppServices/AppSetup.cs` |
 | Custom Mapster config | `IRegister` | `config.Scan(assembly)`, same `AppSetup.cs` |
 | Internal event consumer | `Fluents.EventsConsumers.IHandler<TEvent>` in `AppServices` | `AddServicesFromAssembly` on the in-memory child bus |
-| External (broker) event consumer | same interface in `Minimal.Infra/Features/<Feature>/ExternalEvents/` | `AddServicesFromAssembly` on the Azure child bus — reached only via an explicit `azb.Produce`/`azb.Consume` pair in `ServiceBusSetup.cs` |
+| External (broker) event consumer | same interface in `<YourApp>.Infra/Features/<Feature>/ExternalEvents/` | `AddServicesFromAssembly` on the Azure child bus — reached only via an explicit `azb.Produce`/`azb.Consume` pair in `ServiceBusSetup.cs` |
 
 ## The two shipped samples
 
@@ -92,12 +92,12 @@ Run from the solution root — `dotnet build`/`dotnet test` need no explicit `.s
 ```bash
 dotnet build -c Release
 dotnet test --settings coverage.runsettings --collect:"XPlat Code Coverage"
-dotnet run --project ApiEndpoints/Minimal.Api            # API only
-dotnet run --project ApiEndpoints/Minimal.AppHost        # Redis + PostgreSQL via Aspire
+dotnet run --project ApiEndpoints/<YourApp>.Api            # API only
+dotnet run --project ApiEndpoints/<YourApp>.AppHost        # Redis + PostgreSQL via Aspire
 
 cd ApiEndpoints
-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
 ```
 
 See `dknet-scaffold` for the install/generate steps and how these project names map onto your own

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

@@ -1,12 +1,18 @@
 ---
 name: dknet-queries-specs
-description: Write read/query logic for a DKNet feature — Specification<T> filters, hand-written query requests/handlers dispatched over IMessageBus, and the generic filter/search/order/page list route every generator-driven CRUD slice gets for free. Use after the domain entity and DTO exist, whenever a feature needs anything more than the default GET-by-id.
+description: Write read/query logic for a DKNet feature — the generic filter/search/order/page list route every generator-driven CRUD slice gets for free, Specification<T> filters, and hand-written query requests/handlers over IMessageBus for the shapes that route cannot express. Use after the domain entity and DTO exist, whenever a feature needs anything more than the default GET-by-id.
 ---
 
 # Skill: Queries and Specifications
 
-Covers the read side of a feature: specifications, hand-written queries (`mode=manual`), and the
-generic list route every `[CrudCreate]`-declared entity gets automatically (`mode=auto`).
+Covers the read side of a feature: specifications, the generic list route every `[CrudCreate]`-declared
+entity gets automatically (`mode=auto`), and hand-written queries (`mode=manual`).
+
+**Check the generic list route (§3) before writing a query.** Its `filter`/`search`/`orderBy`/paging
+plus `fromDate`/`toDate` contract covers most list needs with no handler, validator or query object
+at all. Write a hand-written query (§2) only for what it cannot express: a predicate over something
+that is not a DTO field, a projection that is not the DTO, an aggregate/summary shape, or a
+get-by-id that must apply an extra rule.
 
 ## 1. Specifications — why, and the WHERE-FALSE trap
 
@@ -39,7 +45,7 @@ internal sealed class SpecGetPurchaseOrder : Specification<PurchaseOrder>
 }
 ```
 
-(`Minimal.AppServices/ManualSample/V1/Specs/SpecGetPurchaseOrder.cs`; the automated sample's
+(`<YourApp>.AppServices/ManualSample/V1/Specs/SpecGetPurchaseOrder.cs`; the automated sample's
 `SpecGetProduct` and `SpecProductByName` follow the same shape.)
 
 - **`CreatePredicate()`** with no `.And(...)`/`.Or(...)` ever called compiles to `WHERE FALSE`. Any
@@ -51,14 +57,16 @@ internal sealed class SpecGetPurchaseOrder : Specification<PurchaseOrder>
   building `predicator` without ever calling it is a no-op spec.
 - **Specs live in `<Feature>/V1/Specs/`, `internal sealed`** — `SpecGetPurchaseOrder`,
   `SpecGetProduct`, `SpecProductByName` all follow this.
-- **Specs are reused outside query handlers, too.** `SpecProductByName` (`Minimal.AppServices/
+- **Specs are reused outside query handlers, too.** `SpecProductByName` (`<YourApp>.AppServices/
   AutomatedSample/V1/Specs/SpecProductByName.cs`) exists purely so `CreateProductRequestValidator` can
   check for a duplicate name before create — a spec is not only a query-handler concern.
 - **Unit-test a spec without EF Core or a database**: compile `.FilterQuery!.Compile()` into a plain
   `Func<TEntity, bool>` and assert against in-memory instances (`SpecGetPurchaseOrderTests.cs` — see
   [Testing pointers](#5-testing-pointers)).
 
-## 2. Hand-written queries (`mode=manual`)
+## 2. Hand-written queries (`mode=manual`) — the fallback
+
+Reach for this only after §3's generic list route has been ruled out for the shape you need.
 
 A query is a record implementing one of two `SlimBus.Extensions.Fluents.Queries` interfaces,
 dispatched from the endpoint via `IMessageBus.Send(...)` exactly like a command.
@@ -125,7 +133,7 @@ internal sealed class ListPurchaseOrdersQueryHandler(IRepositorySpec repository,
 }
 ```
 
-(`Minimal.AppServices/ManualSample/V1/Queries/GetPurchaseOrderById.cs`,
+(`<YourApp>.AppServices/ManualSample/V1/Queries/GetPurchaseOrderById.cs`,
 `ListPurchaseOrders.cs`.)
 
 - **Nullable paging parameters + `[AsParameters]` + a co-located validator with `.When(x =>
@@ -142,7 +150,7 @@ internal sealed class ListPurchaseOrdersQueryHandler(IRepositorySpec repository,
 ### Aggregate/summary queries over `repository.Query(spec)`
 
 Not every read is "one row" or "a page of rows". `ProductPriceSummaryQuery`
-(`Minimal.AppServices/AutomatedSample/V1/Queries/ProductPriceSummary.cs`) computes a count and an
+(`<YourApp>.AppServices/AutomatedSample/V1/Queries/ProductPriceSummary.cs`) computes a count and an
 average directly against the queryable a spec produces:
 
 ```csharp
@@ -246,7 +254,7 @@ inherit a latent failure.
 
 ### Behavioral spec: `ProductList.feature`
 
-`Minimal.App.BDDTests/Features/Products/ProductList.feature` is the regression fence for this whole
+`<YourApp>.App.BDDTests/Features/Products/ProductList.feature` is the regression fence for this whole
 contract — it exists specifically because nothing in the slice is hand-written, so a future package
 bump could silently change behavior. Representative scenarios:
 
@@ -265,9 +273,9 @@ bump could silently change behavior. Representative scenarios:
 ## 4. Status counts
 
 `group.MapGetStatusCounts<TEntity>("status", new StatusPropertyInfo(nameof(X.Status), typeof(XStatus)))`
-(`Minimal.Api/Configs/Endpoints/StatusCountsEndpointMapperExtensions.cs`) is template-local — not part
+(`<YourApp>.Api/Configs/Endpoints/StatusCountsEndpointMapperExtensions.cs`) is template-local — not part
 of the published `DKNet.AspCore.Extensions` package. It groups rows by an enum-backed property using
-`ModelSpecStatusCounts<TEntity>` (`Minimal.AppServices/Share/Generics/ModelSpecGenericStatusCounts.cs`):
+`ModelSpecStatusCounts<TEntity>` (`<YourApp>.AppServices/Share/Generics/ModelSpecGenericStatusCounts.cs`):
 
 ```csharp
 public class ModelSpecStatusCounts<TEntity> : Specification<TEntity> where TEntity : DomainEntity
@@ -306,11 +314,11 @@ this today; wire it into a `Map(RouteGroupBuilder)` like any other route (see th
 
 - **Spec unit tests** — compile the spec's `.FilterQuery!.Compile()` and assert against
   hand-constructed entities, no EF Core or database involved
-  (`Minimal.App.Tests/Unit/ManualSample/SpecGetPurchaseOrderTests.cs`): a "no filter matches
+  (`<YourApp>.App.Tests/Unit/ManualSample/SpecGetPurchaseOrderTests.cs`): a "no filter matches
   everything" case is the WHERE-FALSE regression guard, plus one case per optional filter argument and
   one for combining them.
 - **List/paging integration tests** — exercise the real HTTP route against `ApiFixture`
-  (`Minimal.App.Tests/Integration/ManualSample/V1/PurchaseOrderListPagingTests.cs`): the shape to copy
+  (`<YourApp>.App.Tests/Integration/ManualSample/V1/PurchaseOrderListPagingTests.cs`): the shape to copy
   is asserting the *declared default* is served when a nullable paging parameter is omitted (not just
   "200 OK"), and asserting an out-of-range value produces the same `ValidationProblemDetails` shape as
   every other validation failure, not a `500`.

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

@@ -81,8 +81,9 @@ re-running the template; change them later by editing `Directory.Packages.props`
 ```
 
 **Path convention:** every other skill in this plugin writes paths relative to the solution root
-using the template's own placeholder names (`Minimal.Api`, `ApiEndpoints/Minimal.Domains/...`) —
-substitute your own `<YourApp>.*` prefix mentally when working in a generated solution.
+with the placeholder `<YourApp>` standing in for your solution prefix (`<YourApp>.Api`,
+`ApiEndpoints/<YourApp>.Domains/...`). Substitute the name you passed to `-n` — a skill never
+hard-codes `Minimal.*`, because that prefix exists only in the template's own source tree.
 
 **No `.claude/`, `.github/`, or `docs/` reaches a generated solution.** Only `AGENTS.md`, the four
 solution-level files above, and `ApiEndpoints/**` are packed (`DKNet.Minimal.Template.nuspec`) —

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

@@ -1,6 +1,6 @@
 ---
 name: dknet-unit-tests
-description: Write xUnit + Shouldly tests for a DKNet.Templates feature in Minimal.App.Tests — architecture/convention rules, pure functional tests (entity methods, validators, specs, mapping), and result-level integration tests against ApiFixture + IMessageBus (handler Result failures, EF persistence, domain events). Use after AppServices actions and endpoint config are ready. Covers only what xUnit owns; HTTP request/response and event-log scenarios belong in the `dknet-bdd-tests` skill. Invoke as `/dknet-unit-tests <Feature> <Entity> [mode=manual|auto]` to scaffold it for a feature.
+description: Write xUnit + Shouldly tests for a DKNet.Templates feature in <YourApp>.App.Tests — architecture/convention rules, pure functional tests (entity methods, validators, specs, mapping), and result-level integration tests against ApiFixture + IMessageBus (handler Result failures, EF persistence, domain events). Use after AppServices actions and endpoint config are ready. Covers only what xUnit owns; HTTP request/response and event-log scenarios belong in the `dknet-bdd-tests` skill. Invoke as `/dknet-unit-tests <Feature> <Entity> [mode=manual|auto]` to scaffold it for a feature.
 metadata:
   kind: workflow
   arguments: "<Feature> <Entity> [mode=manual|auto]"
@@ -9,11 +9,11 @@ allowed-tools: Read, Grep, Glob, Edit, Write, Bash, Agent
 
 Usage: `/dknet-unit-tests <Feature> <Entity> [mode=manual|auto]`
 
-# xUnit tests (Minimal.App.Tests)
+# xUnit tests (<YourApp>.App.Tests)
 
 ## Both shipped suites are teaching material — business tests only
 
-`Minimal.App.Tests` and `Minimal.App.BDDTests` ship inside every generated solution. A team reads them
+`<YourApp>.App.Tests` and `<YourApp>.App.BDDTests` ship inside every generated solution. A team reads them
 to learn how tests are written here, so every test must be about the business domain: the `PurchaseOrder`
 (manual) and `Product` (automated) samples — entity invariants, validators, specs, handler results, CRUD
 over HTTP, domain events.
@@ -26,6 +26,10 @@ sample's business rules, stop and delete the test.
 
 ## Test layering — where a test belongs
 
+**Business behavior goes to BDD first.** If a rule can be stated as "a caller does X and gets Y", it
+belongs in `<YourApp>.App.BDDTests` as a scenario — that is the readable, business-facing record of
+the rule. xUnit is for what a scenario cannot express or cannot distinguish.
+
 xUnit owns three things; BDD must not re-cover them:
 
 1. **Architecture/convention** — `Architecture/*`: NetArchTest + reflection over the compiled assembly
@@ -33,20 +37,21 @@ xUnit owns three things; BDD must not re-cover them:
    expose a domain entity type). Cannot be expressed as an HTTP scenario; never port to BDD.
 2. **Pure functional** — `Unit/*`: entity methods, validators, spec predicate filters, static data. No
    host, no DB, no HTTP.
-3. **Result-level integration** — `Integration/<Feature>/V1/*`: handler failures asserted on the
-   `IResult`/`IResultBase` object (not-found, missing acting user, "already cancelled", 409 precondition
-   codes) and EF model/schema shape. BDD's HTTP-status/response-body assertions are coarser and would lose
-   this intent — keep the `Result`-level assertion here even though the same rule is also proven over HTTP
-   in BDD.
+3. **Result-level integration** — `Integration/<Feature>/V1/*`: EF model/schema shape, and a handler
+   failure asserted on the `IResult`/`IResultBase` object **only when the HTTP response cannot tell it
+   apart from another failure**. Two rules that both answer `400`, or a `NotFoundError` versus an
+   ownership filter that also returns `404`, need the `Result`-level assertion to pin *which* rule
+   fired. A failure whose status code and message already identify it uniquely does not — write that
+   one as a BDD scenario and leave it out of here.
 
 BDD owns user-facing HTTP behavior (request → status → response body) and domain-event side effects
-observed via log capture. Do not duplicate the same behavior in both suites — an HTTP-status check for a
-rule already covered here belongs in BDD instead, not copied into both.
+observed via log capture — which is most of a feature's business rules. Never assert the same rule in
+both suites: pick the suite that states it best, and delete the other copy.
 
-## Fixtures (`Minimal.App.TestSupport` + `Integration/Support`)
+## Fixtures (`<YourApp>.App.TestSupport` + `Integration/Support`)
 
-`TestApiFactoryBase(string? dbName) : WebApplicationFactory<Minimal.Api.Program>` (in
-`Minimal.App.TestSupport`) is the shared host substitution both xUnit and BDD build on. It:
+`TestApiFactoryBase(string? dbName) : WebApplicationFactory<<YourApp>.Api.Program>` (in
+`<YourApp>.App.TestSupport`) is the shared host substitution both xUnit and BDD build on. It:
 
 - Sets `FeatureManagement:RunDbMigrationWhenAppStart/EnableSwagger/EnableAzureAppConfig = false` and
   `ConnectionStrings:AppDb = UseInMemory`.
@@ -143,7 +148,7 @@ public sealed class PurchaseOrderActionsIntegrationTests(ApiFixture fixture) : I
 
 The same class also proves a guarded state transition by calling the handler twice — `Cancel` once
 succeeds, a second `Cancel` on the same order fails with the `precondition.purchase-order-already-cancelled`
-message (`PreconditionCodes`, `Minimal.AppServices/Share/PreconditionCodes.cs`), and every mutating action
+message (`PreconditionCodes`, `<YourApp>.AppServices/Share/PreconditionCodes.cs`), and every mutating action
 fails when `ByUser` is left empty (the acting-user rule the manual mode enforces in the handler itself).
 
 **Precondition branch reachable only over HTTP from xUnit**
@@ -245,7 +250,7 @@ orders.ShouldAllBe(o => o.CreatedBy == SharedConsts.SystemAccount);
 ```
 
 **Architecture rule** (`Architecture/AppServiceTests.cs`), using NetArchTest against the compiled
-`Minimal.AppServices` assembly:
+`<YourApp>.AppServices` assembly:
 
 ```csharp
 var result = Types.InAssembly(typeof(AppSetup).Assembly)
@@ -268,11 +273,11 @@ result.IsSuccessful.ShouldBeTrue();
   violation on a generated CRUD route**; it returns 201/200 (`DKNet.AspCore.Extensions`'s generic
   `Map*<TRequest,TDto>` wrapper isn't visible to the validation source generator). A FluentValidation
   validator still runs on every route. Verify a declared event's composed name against the compiled
-  assembly before asserting on it — `strings bin/**/Minimal.Domains.dll | grep <Entity>`.
+  assembly before asserting on it — `strings bin/**/<YourApp>.Domains.dll | grep <Entity>`.
 
 ## Conventions
 
-- xUnit + Shouldly (`result.IsSuccess.ShouldBeTrue()`, not `Assert.True`). `Minimal.App.Tests.csproj`
+- xUnit + Shouldly (`result.IsSuccess.ShouldBeTrue()`, not `Assert.True`). `<YourApp>.App.Tests.csproj`
   disables analyzers and warnings-as-errors — production code style rules do not apply here.
 - Implicit usings from `GlobalUsings.cs`: `AutoBogus`, `Shouldly`, `System.Text.Json`, `MapsterMapper`,
   plus csproj-level `System.Net`, `Microsoft.Extensions.DependencyInjection`, `Xunit`. Still add explicit
@@ -287,11 +292,11 @@ result.IsSuccessful.ShouldBeTrue();
 ## Commands
 
 ```bash
-dotnet test ApiEndpoints/Minimal.App.Tests/Minimal.App.Tests.csproj --filter "FullyQualifiedName~PurchaseOrder"
+dotnet test ApiEndpoints/<YourApp>.App.Tests/<YourApp>.App.Tests.csproj --filter "FullyQualifiedName~PurchaseOrder"
 dotnet test --settings coverage.runsettings --collect:"XPlat Code Coverage"
 ```
 
-`coverage.runsettings` includes `[DKNet*]*` and `[Minimal*]*`, excludes `*.Tests`/`*Tests` assemblies and
+`coverage.runsettings` includes `[DKNet*]*` and `[<YourApp>*]*`, excludes `*.Tests`/`*Tests` assemblies and
 `**/bin/**, **/obj/**, **/*Tests.cs, **/GlobalUsings.cs, **/*.g.cs` by file — don't put real logic in an
 excluded path expecting it to be measured.
 
@@ -333,7 +338,7 @@ excluded path expecting it to be measured.
 
 The procedure an agent follows when invoked with arguments. The reference sections above are the rules it applies.
 
-You are adding integration tests in `Minimal.App.Tests` that exercise the AppServices and Domains layers through the real DI container.
+You are adding integration tests in `<YourApp>.App.Tests` that exercise the AppServices and Domains layers through the real DI container.
 
 ### Inputs
 
@@ -343,7 +348,7 @@ You are adding integration tests in `Minimal.App.Tests` that exercise the AppSer
 ### Required reading
 
 1. The reference sections above
-2. `ApiEndpoints/Minimal.App.Tests/` — existing fixtures and test patterns (`Architecture/`, `Integration/`, `Unit/`).
+2. `ApiEndpoints/<YourApp>.App.Tests/` — existing fixtures and test patterns (`Architecture/`, `Integration/`, `Unit/`).
 
 ### Steps
 
@@ -370,7 +375,7 @@ You are adding integration tests in `Minimal.App.Tests` that exercise the AppSer
      the gap is correct. Note the gap in the report instead.
 2. Run only the affected tests:
    ```
-   dotnet test ApiEndpoints/Minimal.App.Tests/Minimal.App.Tests.csproj --filter "FullyQualifiedName~<Entity>"
+   dotnet test ApiEndpoints/<YourApp>.App.Tests/<YourApp>.App.Tests.csproj --filter "FullyQualifiedName~<Entity>"
    ```
 3. If any test fails, fix the test or product code (per skill guidance) — do not relax assertions.
 4. Report: test file path, count, pass/fail, coverage areas hit.

package/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "dknet-minimal",
   "description": "Agent skills and agents for building vertical-slice DDD/CQRS features on solutions generated from DKNet.Minimal.Template (.NET 10, EF Core, .NET Aspire, SlimMessageBus, FluentValidation, Mapster, Reqnroll BDD).",
-  "version": "14.1.0",
+  "version": "14.2.0",
   "author": {
     "name": "baoduy"
   },
@@ -19,8 +19,8 @@
     "slimmessagebus",
     "fluentvalidation"
   ],
-  "agents": "agents/",
+  "agents": "plugin/agents/",
   "skills": [
-    "skills/"
+    "plugin/skills/"
   ]
 }