@atlashub/smartstack-cli 3.37.0 → 3.38.0

package/templates/skills/application/steps/step-00-init.md

@@ -22,156 +22,26 @@ Initialize the application/module creation by parsing parameters, detecting leve
 
 ## EXECUTION SEQUENCE
 
-### 1. Detect Navigation Level
+### 1-4. Parameter Detection & Project Analysis
 
-From user request, identify the level:
-
-| Hint in Request | → Level | Parent Required |
-|-----------------|---------|-----------------|
-| "context", "workspace", "nouveau contexte" | context | No |
-| "application", "app", "nouvelle application" | application | Yes (context) |
-| "module", "feature", "nouveau module" | module | Yes (context.application) |
-| "section", "tab", "nouvelle section" | section | Yes (context.app.module) |
-
-### 2. Extract Parameters
-
-```yaml
-# Required
-level: context | application | module | section
-code: kebab-case (e.g., "products", "order-management")
-labels:
-  fr: "Label français"
-  en: "English label"
-  it: "Etichetta italiana"
-  de: "Deutsche Bezeichnung"
-icon: Lucide icon name (e.g., "Package", "ShoppingCart")
-displayOrder: number
-
-# Conditional (required for non-context levels)
-parentPath: "context.application.module" (dot-separated)
-```
-
-### 3. MCP Prerequisite Check (BLOCKING)
-
-**CRITICAL:** This check is **BLOCKING** - the skill cannot proceed without MCP.
-
-> See `_shared.md` → "MCP Prerequisite Guard (BLOCKING)" for the full pattern.
-
-```
-Call: mcp__smartstack__validate_conventions
-Args: { checks: ["tables"] }
-```
-
-**On success:** Set `mcp_available = true`, continue to Step 4.
-
-**On failure (STOP):**
-
-```
-═══════════════════════════════════════════════════════════════
-  MCP SMARTSTACK NOT AVAILABLE - SKILL BLOCKED
-═══════════════════════════════════════════════════════════════
-
-  The SmartStack MCP server is required for the application
-  skill but could not be reached.
-
-  To install:
-    claude mcp add smartstack -- npx --package @atlashub/smartstack-cli smartstack-mcp
-
-  To verify:
-    /mcp:healthcheck
-
-  After installation, restart Claude Code and retry.
-
-═══════════════════════════════════════════════════════════════
-```
-
-**DO NOT** offer manual instructions or degraded execution.
-**DO NOT** proceed with step files.
-**STOP the skill immediately.**
-
-### 4. Detect Project Type
-
-Read `.smartstack/config.json` at the project root to determine the seeding strategy:
-
-```
-Read: .smartstack/config.json
-Extract: projectType, dbContext
-```
-
-| projectType | dbContext | Seeding Strategy |
-|-------------|----------|-----------------|
-| `core` | `core` | HasData() in Configuration files (existing pattern) |
-| `client` | `extensions` | IClientSeedDataProvider (runtime seeding) |
-
-**If file not found or projectType missing:** Default to `core` / `hasdata`.
-
-Store:
-```
-{project_type} = "core" or "client"
-{db_context} = "core" or "extensions"
-{seeding_strategy} = "hasdata" or "provider"
-```
-
-### 4b. Detect Feature.json Context (Optional Enrichment)
-
-Search for a Business Analysis feature.json for the target module:
-
-```
-Glob: docs/business/*/{code}/business-analyse/v*/feature.json
-      .business-analyse/business/*/modules/{code}/features/*/feature.json
-```
-
-**If found (status = "handed-off" or "consolidated"):**
-
-Read the feature.json and extract context for subsequent steps:
-
-| feature.json Section | Used In Step | Extracted Data |
-|----------------------|-------------|----------------|
-| `analysis.entities[]` | step-04 (backend) | Entity names, attributes, relationships, validations |
-| `specification.useCases[]` | step-04 (backend) | API endpoint definitions beyond basic CRUD |
-| `specification.permissionMatrix` | step-02 (permissions) | Custom permission paths and role assignments |
-| `specification.apiEndpoints[]` | step-04 (backend) | Exact HTTP methods, routes, DTOs |
-| `specification.navigation` | step-01 (navigation) | Navigation hierarchy with labels and icons |
-| `specification.i18nKeys` | step-05 (frontend) | Pre-defined translation keys |
-| `specification.validations[]` | step-04 (backend) | Field-level validation rules |
-| `specification.uiWireframes[]` | step-05 (frontend) | UI layout guidance |
-| `specification.seedDataCore` | step-01, step-02, step-03 | Pre-computed seeds |
-| `analysis.businessRules[]` | step-04, step-07 | Business rules for service logic and tests |
-| `specification.lifeCycles[]` | step-04 (backend) | Entity state machines |
-| `specification.dashboards` | step-05 (frontend) | Dashboard KPIs and chart specs |
-| `documentation` | step-08 | userDocRequired / techDocRequired flags |
-
-Store:
-```
-{feature_json_path} = "path/to/feature.json" or null
-{has_feature_context} = true or false
-{feature_data} = parsed feature.json object (if found)
-```
-
-**If NOT found or status not in ["handed-off", "consolidated"]:**
-
-```
-{has_feature_context} = false
-```
-
-Continue normally. All subsequent steps use their standard generation logic (generic CRUD).
-
-> **When `{has_feature_context} = true`**, subsequent steps SHOULD use the feature.json data
-> to generate more accurate code: entities with correct attributes and relationships, custom
-> permissions beyond basic CRUD, specific API routes, validation rules, and business logic
-> in services. This reduces post-generation manual corrections significantly.
+See [references/init-parameter-detection.md](../references/init-parameter-detection.md) for:
+- Navigation level detection (application/module/section)
+- Parameter extraction (code, labels, icon, displayOrder)
+- Project type & seeding strategy detection
+- Feature.json context enrichment (optional)
+- MCP prerequisite validation (BLOCKING)
 
 ### 5. Build Full Path
 
 ```
 {full_path} = {parentPath}.{code}  (if parentPath exists)
-{full_path} = {code}               (if context level)
+{full_path} = {code}               (if application level)
 
 Example:
   level: module
-  parentPath: erp.sales
+  parentPath: sales
   code: products
-  → full_path: erp.sales.products
+  → full_path: sales.products
 ```
 
 ### 6. Infer Descriptions (if not provided)
@@ -218,7 +88,7 @@ descriptions:
 
 | Variable | Description |
 |----------|-------------|
-| `{level}` | context, application, module, or section |
+| `{level}` | application, module, or section |
 | `{code}` | kebab-case identifier |
 | `{full_path}` | Complete navigation path |
 | `{parent_path}` | Parent path (null for context) |

package/templates/skills/application/steps/step-01-navigation.md

@@ -29,7 +29,7 @@ From step-00-init:
 
 | Variable | Description |
 |----------|-------------|
-| `{level}` | context, application, module, or section |
+| `{level}` | application, module, or section |
 | `{code}` | kebab-case identifier |
 | `{full_path}` | Complete navigation path |
 | `{parent_path}` | Parent path (null for context) |
@@ -55,7 +55,7 @@ Tool: mcp__smartstack__scaffold_navigation
 Args:
   level: "{level}"
   code: "{code}"
-  parentPath: "{parent_path}"  # Omit if level is "context"
+  parentPath: "{parent_path}"  # Omit if level is "application" (top-level)
   labels:
     fr: "{labels.fr}"
     en: "{labels.en}"
@@ -158,7 +158,7 @@ See [references/nav-fallback-procedure.md](../references/nav-fallback-procedure.
 
 ## FAILURE MODES
 
-- Missing parent path for non-context level (return to step-00)
+- Missing parent path for non-application level (return to step-00)
 - Invalid level (return to step-00)
 - Parent entity not found in existing seeds (ask user for parent GUID)
 

package/templates/skills/application/steps/step-02-permissions.md

@@ -28,7 +28,7 @@ From previous steps:
 
 | Variable | Description |
 |----------|-------------|
-| `{level}` | context, application, module, or section |
+| `{level}` | application, module, or section |
 | `{full_path}` | Complete navigation path (navRoute) |
 | `{navigation_guid}` | GUID of the navigation entity |
 | `{labels}` | Object with fr, en, it, de |
@@ -45,7 +45,7 @@ For permissions, the navRoute is the `{full_path}`:
 
 ```
 navRoute = "{full_path}"
-Example: "erp.sales.products"
+Example: "sales.products"
 ```
 
 ### 2. Call MCP generate_permissions
@@ -76,7 +76,7 @@ Add to `Application/Common/Authorization/Permissions.cs`:
 
 **Usage in Controller:**
 ```csharp
-[RequirePermission(Permissions.{Context}.{Application}.{Module}.Read)]
+[RequirePermission(Permissions.{Application}.{Module}.Read)]
 public async Task<ActionResult> GetAll() { ... }
 ```
 ```
@@ -186,7 +186,7 @@ If MCP call fails:
 ## FAILURE MODES
 
 - MCP call failed (display error, stop)
-- Invalid navRoute format (must be context.application.module)
+- Invalid navRoute format (must be application.module)
 - Missing navigation entity (return to step-01)
 
 ---

package/templates/skills/application/steps/step-03-roles.md

@@ -37,7 +37,7 @@ From previous steps:
 | Variable | Description |
 |----------|-------------|
 | `{full_path}` | Complete navigation path (navRoute) |
-| `{level}` | context, application, module, or section |
+| `{level}` | application, module, or section |
 | `{permission_guids}` | GUIDs for generated permissions |
 | `{mcp_available}` | Boolean - MCP connectivity status |
 | `{project_type}` | "core" or "client" |
@@ -49,13 +49,10 @@ From previous steps:
 
 ### 1. Determine Default Role Assignments
 
-Based on navigation context, apply default role mappings:
-
-| Context | PlatformAdmin | TenantAdmin | StandardUser |
-|---------|---------------|-------------|--------------|
-| `platform.*` | Full CRUD | Read only | None |
-| `business.*` | Full CRUD | Full CRUD | Read only |
-| `personal.*` | None | Full CRUD | Full CRUD |
+See [references/roles-client-project-handling.md](../references/roles-client-project-handling.md) for:
+- Default role mapping table by application prefix
+- ApplicationRolesSeedData.cs requirements (once per application)
+- {Module}RolePermissionSeedData.cs requirements (per module)
 
 ### 2. Call MCP scaffold_role_permissions
 
@@ -134,178 +131,24 @@ If MCP call fails or `{mcp_available}` = false:
 
 > **Condition:** `{seeding_strategy}` = "provider"
 
-**For core (`{seeding_strategy}` = "hasdata"):** Write in RolePermissionConfiguration.cs (existing pattern)
-
-**For client (`{seeding_strategy}` = "provider"):** DO NOT write in RolePermissionConfiguration.cs (does not exist in client projects).
-
-Instead, create TWO files:
-
-### 1. ApplicationRolesSeedData.cs (ONCE per application)
-
-**File:** `Infrastructure/Persistence/Seeding/Data/ApplicationRolesSeedData.cs`
-
-**Purpose:** Defines the 4 standard application-scoped roles (Admin, Manager, Contributor, Viewer) with valid `Code` values.
-
-**CRITICAL:** Without this file, role-permission mappings in `SeedRolePermissionsAsync()` will fail silently because `roles.FirstOrDefault(r => r.Code == mapping.RoleCode)` will return null.
-
-See [references/application-roles-template.md](../references/application-roles-template.md) for the complete template.
-
-**Key requirements:**
-- Deterministic GUIDs based on `role-{applicationId}-{roleType}`
-- 4 roles: Admin, Manager, Contributor, Viewer
-- Each role has a valid `Code` property ("admin", "manager", "contributor", "viewer")
-- `ApplicationId` references the navigation application GUID
-- `IsSystem = false` (application-scoped, not system roles)
-
-**Detection:** Check if ApplicationRolesSeedData.cs exists. If yes, skip creation (already exists from Module 1). If no, create it.
-
-### 2. {Module}RolePermissionSeedData.cs (PER module)
-
-**File:** `Infrastructure/Persistence/Seeding/Data/{Domain}/{Module}RolePermissionSeedData.cs`
-
-**Purpose:** Maps permissions to roles by Code (e.g., "admin" → "{navRoute}.*").
-
-Content: static class with method `GetRolePermissionEntries()` that returns the role-permission mapping data.
-These entries will be consumed by the `IClientSeedDataProvider` at step 03b.
-
-**After creating both files:** Proceed to step-03b-provider.md (which will skip for core projects).
+See [references/roles-client-project-handling.md](../references/roles-client-project-handling.md) for:
+- ApplicationRolesSeedData.cs creation (once per application)
+- {Module}RolePermissionSeedData.cs creation (per module)
+- Role code naming and GUID generation rules
+- Detection of existing ApplicationRolesSeedData.cs
 
 ---
 
 ## FALLBACK PROCEDURE (When MCP Unavailable)
 
-> This procedure generates role-permission HasData entries following SmartStack.app patterns.
-
-### F1. Read Existing RolePermissionConfiguration.cs
-
-```
-Glob: **/Persistence/Configurations/Authorization/RolePermissionConfiguration.cs
-```
-
-Read the file to determine:
-- Existing role-permission mappings
-- The GetSeedData() method structure
-- Which roles already have which permissions
-- The GUID generation method used (deterministic or hardcoded)
-
-### F2. Read Role GUIDs
-
-**System-level roles** (well-known GUIDs):
-
-| Role | GUID |
-|------|------|
-| SuperAdmin | `11111111-1111-1111-1111-111111111111` |
-| PlatformAdmin | `22222222-2222-2222-2222-222222222222` |
-| TenantAdmin | `33333333-3333-3333-3333-333333333333` |
-| StandardUser | `44444444-4444-4444-4444-444444444444` |
-
-**IMPORTANT:** Read the actual `RoleSeedData.cs` or `RoleConfiguration.cs` in the target project to confirm the actual role GUIDs. The above are defaults; the project may use different values.
-
-**Application-scoped roles** (deterministic GUIDs based on application):
-
-```csharp
-// Read the existing GenerateDeterministicGuid method in RolePermissionConfiguration.cs
-// Typically uses MD5 hash:
-private static Guid GenerateDeterministicGuid(Guid applicationId, string roleType)
-{
-    using var md5 = System.Security.Cryptography.MD5.Create();
-    var input = $"{applicationId}-{roleType}";
-    var hash = md5.ComputeHash(System.Text.Encoding.UTF8.GetBytes(input));
-    return new Guid(hash);
-}
-// roleType values: "admin", "manager", "contributor", "viewer"
-```
-
-Find the `applicationId` from `NavigationApplicationSeedData.cs` matching `{full_path}`.
-
-### F3. Determine Context-Based Default Mappings
-
-Based on `{full_path}` prefix:
-
-| Context Prefix | SuperAdmin | PlatformAdmin | App Admin | App Manager | App Contributor | App Viewer |
-|----------------|------------|---------------|-----------|-------------|-----------------|------------|
-| `platform.*` | wildcard | Full CRUD | Full CRUD | CRU | CR | R |
-| `business.*` | wildcard | Full CRUD | Full CRUD | CRU | CR | R |
-| `personal.*` | wildcard | None | Full CRUD | CRU | CR | R |
-
-### F4. Generate RolePermission HasData Entries
-
-Using `{permission_guids}` from step-02:
-
-```csharp
-// In RolePermissionConfiguration.cs - GetSeedData() method
-var seedDate = SeedConstants.SeedDate;
-
-// ============================================================
-// {MODULE_NAME} PERMISSIONS
-// ============================================================
-
-// SuperAdmin: already has *.* wildcard - no individual entries needed
-
-// PlatformAdmin (for platform.* context)
-rolePermissions.Add(new { RoleId = platformAdminRoleId, PermissionId = {permission_guids.read}, AssignedAt = seedDate });
-rolePermissions.Add(new { RoleId = platformAdminRoleId, PermissionId = {permission_guids.create}, AssignedAt = seedDate });
-rolePermissions.Add(new { RoleId = platformAdminRoleId, PermissionId = {permission_guids.update}, AssignedAt = seedDate });
-rolePermissions.Add(new { RoleId = platformAdminRoleId, PermissionId = {permission_guids.delete}, AssignedAt = seedDate });
-
-// Application-scoped: Admin → wildcard
-rolePermissions.Add(new { RoleId = appAdminRoleId, PermissionId = {permission_guids.wildcard}, AssignedAt = seedDate });
-
-// Application-scoped: Manager → CRU (read + create + update — no delete)
-rolePermissions.Add(new { RoleId = appManagerRoleId, PermissionId = {permission_guids.read}, AssignedAt = seedDate });
-rolePermissions.Add(new { RoleId = appManagerRoleId, PermissionId = {permission_guids.create}, AssignedAt = seedDate });
-rolePermissions.Add(new { RoleId = appManagerRoleId, PermissionId = {permission_guids.update}, AssignedAt = seedDate });
-
-// Application-scoped: Contributor → CR
-rolePermissions.Add(new { RoleId = appContributorRoleId, PermissionId = {permission_guids.read}, AssignedAt = seedDate });
-rolePermissions.Add(new { RoleId = appContributorRoleId, PermissionId = {permission_guids.create}, AssignedAt = seedDate });
-
-// Application-scoped: Viewer → R
-rolePermissions.Add(new { RoleId = appViewerRoleId, PermissionId = {permission_guids.read}, AssignedAt = seedDate });
-```
-
-### F5. Write Code to RolePermissionConfiguration.cs
-
-**CRITICAL:** Do NOT just display code. WRITE it to the actual file.
-
-1. Open `RolePermissionConfiguration.cs`
-2. Find the `GetSeedData()` method
-3. Add the new role-permission entries to the list
-4. Add necessary permission GUID references (import from PermissionConfiguration or use inline)
-5. Add comments grouping the new entries: `// {MODULE_NAME} PERMISSIONS`
-
-### F6. Present Summary
-
-```markdown
-## Role-Permission Mappings Generated (Fallback)
-
-| Role | Permissions |
-|------|-------------|
-| SuperAdmin | Already has wildcard access |
-| PlatformAdmin | {full_path}.read, .create, .update, .delete |
-| App Admin | {full_path}.* (wildcard) |
-| App Manager | {full_path}.read, .create, .update |
-| App Contributor | {full_path}.read, .create |
-| App Viewer | {full_path}.read |
-
-Written to: RolePermissionConfiguration.cs
-```
-
-### F7. Offer User Adjustment
-
-```yaml
-questions:
-  - header: "Role Access"
-    question: "Default role-permission mappings have been applied. Adjust?"
-    options:
-      - label: "Keep defaults (Recommended)"
-        description: "Standard role hierarchy applied"
-      - label: "Custom adjustments"
-        description: "I want to change specific role permissions"
-    multiSelect: false
-```
-
-If user selects "Custom adjustments", ask which roles/permissions to change and update the file accordingly.
+See [references/roles-fallback-procedure.md](../references/roles-fallback-procedure.md) for the complete 7-step fallback:
+- **F1:** Read existing RolePermissionConfiguration.cs to determine state
+- **F2:** Read role GUIDs (system-level and application-scoped)
+- **F3:** Determine default mappings based on application prefix
+- **F4:** Generate RolePermission HasData entries using permission GUIDs
+- **F5:** Write code to RolePermissionConfiguration.cs (CRITICAL: WRITE not display)
+- **F6:** Present summary
+- **F7:** Offer user adjustment option
 
 ---
 

package/templates/skills/application/steps/step-03b-provider.md

@@ -33,7 +33,7 @@ From previous steps:
 
 | Variable | Description |
 |----------|-------------|
-| `{level}` | context, application, module, or section |
+| `{level}` | application, module, or section |
 | `{code}` | kebab-case identifier |
 | `{full_path}` | Complete navigation path |
 | `{labels}` | Object with fr, en, it, de |
@@ -82,7 +82,6 @@ Using the SeedData files as data sources, generate the `{AppPascalName}SeedDataP
 Adapt the template:
 - Replace `{AppPascalName}` with the PascalCase application name
 - Replace `{app_code}` with the kebab-case application code
-- Replace `{context_code}` with the parent context code
 - Fill in the actual navigation, permission, and role-permission creation logic
   using the helper methods from the SeedData classes
 

package/templates/skills/application/steps/step-04-backend.md

@@ -32,7 +32,7 @@ From previous steps:
 
 | Variable | Description |
 |----------|-------------|
-| `{level}` | context, application, module, or section |
+| `{level}` | application, module, or section |
 | `{code}` | kebab-case identifier |
 | `{full_path}` | Complete navigation path (navRoute) |
 | `{labels}` | Object with fr, en, it, de |
@@ -53,32 +53,12 @@ code: "user-profiles"   → entityName: "UserProfile"
 
 ### 2. Determine Table Prefix and Controller Folder
 
-**Table Prefix priority:**
-1. **If a `feature.json` exists** with `metadata.tablePrefix` → use that prefix (e.g., `rh_`, `fi_`)
-2. **Otherwise**, derive from navigation context using the fallback table below
-
-**Fallback table (when no feature.json tablePrefix is available):**
-
-| Context | Table Prefix | Controller Folder |
-|---------|--------|-------------------|
-| platform.administration | `auth_` or `cfg_` | `Admin` |
-| platform.support | `support_` | `Support` |
-| business.* | `ref_` or domain-specific | `Business` |
-| personal.* | `usr_` | `User` |
-
-```
-# Check for feature.json tablePrefix
-Search for feature.json in:
-  - docs/business/{application}/business-analyse/*/feature.json
-  - Read metadata.tablePrefix if exists
-
-IF metadata.tablePrefix exists:
-  {prefix} = metadata.tablePrefix   # e.g., "rh_"
-ELSE:
-  {prefix} = derived from context table above
-```
-
-Store: `{controller_folder}` = the Controller Folder from the table above.
+See [references/backend-table-prefix-mapping.md](../references/backend-table-prefix-mapping.md) for:
+- Table prefix priority (feature.json vs. fallback)
+- Application-to-prefix mapping table
+- Feature.json detection and extraction
+- Controller folder organization
+- Store `{controller_folder}` from the mapping
 
 ### 3. Call MCP scaffold_extension
 
@@ -100,93 +80,22 @@ Args:
 
 ### 4. Parse MCP Response
 
-The tool generates (paths organized by navRoute hierarchy `{context}.{application}.{module}`):
-- `Domain/{Context}/{Application}/{Module}/{EntityName}.cs` - Entity with BaseEntity
-- `Infrastructure/Persistence/Configurations/{Context}/{Application}/{Module}/{EntityName}Configuration.cs` - EF Config
+The tool generates (paths organized by navRoute hierarchy `{application}.{module}`):
+- `Domain/{Application}/{Module}/{EntityName}.cs` - Entity with BaseEntity
+- `Infrastructure/Persistence/Configurations/{Application}/{Module}/{EntityName}Configuration.cs` - EF Config
 - `Application/Common/Interfaces/I{EntityName}Service.cs` - Service Interface
-- `Infrastructure/Services/{Context}/{Application}/{Module}/{EntityName}Service.cs` - Service Implementation
+- `Infrastructure/Services/{Application}/{Module}/{EntityName}Service.cs` - Service Implementation
 - `Api/Controllers/{controller_folder}/{Application}/{EntityName}Controller.cs` - REST Controller
-- `Application/{Context}/{Application}/{Module}/DTOs/{EntityName}ResponseDto.cs` - Response DTO
-- `Application/{Context}/{Application}/{Module}/DTOs/Create{EntityName}Dto.cs` - Create request
-- `Application/{Context}/{Application}/{Module}/DTOs/Update{EntityName}Dto.cs` - Update request
-
-### 5. Present Output to User
-
-```markdown
-## Backend Code Generated
-
-### Domain Layer
-- `Domain/{Context}/{Application}/{Module}/{EntityName}.cs`
-
-### Infrastructure Layer
-- `Persistence/Configurations/{Context}/{Application}/{Module}/{EntityName}Configuration.cs`
-- `Services/{Context}/{Application}/{Module}/{EntityName}Service.cs`
-
-### Application Layer
-- `Common/Interfaces/I{EntityName}Service.cs`
-- `{Context}/{Application}/{Module}/DTOs/{EntityName}ResponseDto.cs`
-- `{Context}/{Application}/{Module}/DTOs/Create{EntityName}Dto.cs`
-- `{Context}/{Application}/{Module}/DTOs/Update{EntityName}Dto.cs`
-
-### API Layer
-- `Controllers/{controller_folder}/{Application}/{EntityName}Controller.cs`
-  - NavRoute: `{full_path}`
-  - Endpoints:
-    - GET /api/{code} - List all
-    - GET /api/{code}/{id} - Get by ID
-    - POST /api/{code} - Create
-    - PUT /api/{code}/{id} - Update
-    - DELETE /api/{code}/{id} - Delete
-
-### Next Steps
-1. Add DbSet to ICoreDbContext: `public DbSet<{EntityName}> {EntityName}s => Set<{EntityName}>();`
-2. Register service in DI: `services.AddScoped<I{EntityName}Service, {EntityName}Service>();`
-3. Run: `dotnet ef migrations add core_vX.X.X_XXX_Add{EntityName}`
-```
-
-### 6. Entity Seeding (Optional)
-
-> Ask the user if they want to seed initial data for the entity.
-> This creates runtime seed data (applied at startup via DevDataSeeder), following the same
-> architecture as core (SeedData provider pattern).
-
-```yaml
-questions:
-  - header: "Seed Data"
-    question: "Would you like to generate initial seed data for {EntityName}?"
-    options:
-      - label: "Yes - Generate SeedData provider"
-        description: "Creates {EntityName}SeedData.cs + registers in DevDataSeeder (same pattern as core)"
-      - label: "No - Skip seeding"
-        description: "Entity starts empty (can add seed data later)"
-    multiSelect: false
-```
+- `Application/{Application}/{Module}/DTOs/{EntityName}ResponseDto.cs` - Response DTO
+- `Application/{Application}/{Module}/DTOs/Create{EntityName}Dto.cs` - Create request
+- `Application/{Application}/{Module}/DTOs/Update{EntityName}Dto.cs` - Update request
 
-#### If User Selects YES:
+### 5-7. Present Output, Entity Seeding & Store Info
 
-See [references/backend-entity-seeding.md](../references/backend-entity-seeding.md) for the full seeding pattern:
-1. **SeedData file** (`{EntityName}SeedData.cs`) — static class with deterministic GUIDs, 3-5 samples
-2. **DevDataSeeder update** — add `Seed{EntityName}sAsync()` method with idempotent check
-
-#### If User Selects NO:
-
-Skip this section and proceed to storing entity info.
-
-```markdown
-> Skipping entity seed data. You can generate it later using the SeedData provider pattern
-> documented in templates-seed.md.
-```
-
-### 7. Store Entity Info
-
-Store entity information for frontend generation:
-
-```
-{entity_name} = "{EntityName}"
-{entity_code} = "{code}"
-{api_route} = "/api/{code}"
-{has_seed_data} = true/false  // Whether SeedData provider was generated
-```
+See [references/backend-seeding-and-dto-output.md](../references/backend-seeding-and-dto-output.md) for:
+- Output formatting by layer (Domain, Infrastructure, Application, API)
+- Entity seeding questions and responses
+- Entity info storage for frontend generation
 
 ---