@atlashub/smartstack-cli 3.36.0 → 3.38.0

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
 
 ---
 

package/templates/skills/application/steps/step-05-frontend.md

@@ -42,15 +42,11 @@ From previous steps:
 
 ## ROUTE NAMING RULE
 
-> **BLOCKING:** All route paths MUST use **kebab-case** to match navigation seed data exactly.
->
-> - Transformation: `PascalCase` → `kebab-case` (e.g., `HumanResources` → `human-resources`)
-> - Single words stay lowercase: `Employees` → `employees`
-> - Multi-word segments MUST have hyphens: `TimeManagement` → `time-management`
-> - **FORBIDDEN:** `humanresources`, `timemanagement` (concatenated words without hyphens)
-> - **REQUIRED:** `human-resources`, `time-management` (proper kebab-case)
->
-> Route paths MUST match the navigation seed data routes (which use `ToKebabCase()`).
+See [references/frontend-route-naming.md](../references/frontend-route-naming.md) for:
+- Kebab-case transformation rules
+- Forbidden patterns (concatenated words)
+- Required patterns (hyphens in multi-word segments)
+- Verification against navigation seed data
 
 ---
 
@@ -65,7 +61,7 @@ Args:
   name: "{entity_name}"
   options:
     navRoute: "{full_path}"
-    outputPath: "web/src/pages/{context}/{application}/{module}"
+    outputPath: "web/src/pages/{application}/{module}"
     dryRun: false
 ```
 
@@ -116,123 +112,19 @@ This generates:
 
 ### 4. Wire Routes to App.tsx (BLOCKING)
 
-> **CRITICAL:** This step is MANDATORY. Without it, routes exist as files but are invisible to the React Router. The page will be BLANK.
+See [references/frontend-route-wiring-app-tsx.md](../references/frontend-route-wiring-app-tsx.md) for:
+- Step 4a: Import page components
+- Step 4b: Detect App.tsx routing pattern (Pattern A vs Pattern B)
+- Step 4c: Application-to-Layout mapping table
+- Step 4d: Route wiring verification
+- Forbidden patterns (absolute paths, outside Layout, createBrowserRouter)
 
-After `scaffold_routes` generates the route files, you MUST manually insert the routes into `App.tsx`.
+### 5-6. Verify i18n & Present Output
 
-**Step 4a:** Import the page components at the top of App.tsx:
-
-```tsx
-import { {EntityName}Page } from '@/pages/{Context}/{Application}/{Module}/{EntityName}Page';
-// Or lazy-loaded:
-const {EntityName}Page = lazy(() => import('@/pages/{Context}/{Application}/{Module}/{EntityName}Page'));
-```
-
-**Step 4b:** Detect the App.tsx routing pattern:
-
-Read App.tsx and detect which pattern is used:
-
-**Pattern A** — If App.tsx contains `contextRoutes: ContextRouteExtensions`:
-  → Add routes to `contextRoutes.{context}[]` with **RELATIVE** paths (no leading `/`)
-
-  ```tsx
-  const contextRoutes: ContextRouteExtensions = {
-    business: [
-      // existing routes...
-      { path: '{application_kebab}/{module_kebab}', element: <{EntityName}ListPage /> },
-      { path: '{application_kebab}/{module_kebab}/new', element: <Create{EntityName}Page /> },
-      { path: '{application_kebab}/{module_kebab}/:id', element: <{EntityName}DetailPage /> },
-      { path: '{application_kebab}/{module_kebab}/:id/edit', element: <Create{EntityName}Page /> },
-    ],
-  };
-  ```
-
-  Routes are automatically injected into BOTH standard (`/business/...`) and tenant-prefixed (`/t/:slug/business/...`) route trees by `mergeRoutes()`. No manual duplication needed.
-
-**Pattern B** — If App.tsx contains `<Route path="/{context}" element={<{Layout} />}>` (JSX Routes):
-  → Insert `<Route>` children inside the Layout wrapper (see below)
-
-  ```tsx
-  <Route path="/business" element={<BusinessLayout />}>
-    {/* ... existing routes ... */}
-    <Route path="{application_kebab}/{module_kebab}" element={<{EntityName}Page />} />
-  </Route>
-  ```
-
-  ALSO add the same routes inside the tenant-prefixed block:
-  Find `<Route path="/t/:slug">` and add the **same route entries** there.
-
-**Step 4c:** Context-to-Layout mapping:
-
-| Context | Layout Component | Route path |
-|---------|------------------|------------|
-| `platform.*` | `AdminLayout` | `/platform` |
-| `business.*` | `BusinessLayout` | `/business` |
-| `personal.*` | `UserLayout` | `/personal/myspace` |
-
-**Step 4d:** Verify wiring:
-
-```
-Tool: mcp__smartstack__validate_frontend_routes
-Args:
-  scope: "routes"
-```
-
-If `appWiring.issues` is not empty, fix the wiring before proceeding.
-
-**FORBIDDEN (both patterns):**
-- Adding business/platform/personal routes to `clientRoutes[]` with absolute paths — `clientRoutes` is ONLY for routes outside SmartStack contexts (e.g., `/about`, `/pricing`)
-- Adding routes OUTSIDE the Layout wrapper (shell will not render)
-- Using `createBrowserRouter` (SmartStack uses `useRoutes()` + `mergeRoutes()`)
-
-### 5. Verify i18n Files
-
-> **Note:** i18n files are now auto-generated by `type: "page"` scaffold (step 1).
-> Verify the 4 language files were created and customize the `title`/`subtitle` with the proper labels.
-
-If the generated translations need customization (e.g., replacing generic title with `{labels.fr}`):
-- `i18n/locales/fr/{entityCode}.json` → set `"title": "{labels.fr}"`
-- `i18n/locales/en/{entityCode}.json` → set `"title": "{labels.en}"`
-- `i18n/locales/it/{entityCode}.json` → set `"title": "{labels.it}"`
-- `i18n/locales/de/{entityCode}.json` → set `"title": "{labels.de}"`
-
-### 6. Present Output to User
-
-```markdown
-## Frontend Code Generated
-
-### Pages
-- `pages/{context}/{application}/{module}/{EntityName}Page.tsx`
-- `pages/{context}/{application}/{module}/{EntityName}ListView.tsx`
-
-### Components
-- `components/{context}/{module}/{EntityName}.tsx`
-- `hooks/use{EntityName}.ts`
-
-### API Client
-- `services/api/{entityCode}Api.ts`
-- `types/{entityName}.types.ts`
-
-### Routes
-- Updated `navRoutes.generated.ts`
-- Generated `clientRoutes.generated.tsx`
-- Wired routes in `App.tsx` (standard + tenant blocks)
-
-### i18n
-- `locales/fr/{entityCode}.json`
-- `locales/en/{entityCode}.json`
-- `locales/it/{entityCode}.json`
-- `locales/de/{entityCode}.json`
-
-### Route Configuration
-```tsx
-// In routes.tsx - NESTED routes (not flat!)
-<Route path="{application_kebab}">
-  <Route index element={<Navigate to="{module_kebab}" replace />} />
-  <Route path="{module_kebab}" element={<{EntityName}Page />} />
-</Route>
-```
-```
+See [references/frontend-i18n-and-output.md](../references/frontend-i18n-and-output.md) for:
+- i18n structure (4 language files)
+- Customization of labels from feature context
+- Output formatting by category (Pages, Components, API Client, Routes, i18n)
 
 ---
 
@@ -244,24 +136,6 @@ See [references/frontend-verification.md](../references/frontend-verification.md
 
 ---
 
-## I18N STRUCTURE
-
-All i18n files must follow this structure:
-
-```
-locales/
-├── fr/
-│   └── {entityCode}.json
-├── en/
-│   └── {entityCode}.json
-├── it/
-│   └── {entityCode}.json
-└── de/
-    └── {entityCode}.json
-```
-
----
-
 ## POST-GENERATION VERIFICATION (MANDATORY)
 
 **Before proceeding to step-06, run all 7 checks on generated frontend files.**

package/templates/skills/application/steps/step-06-migration.md

@@ -39,26 +39,11 @@ From previous steps:
 
 ### 0. Pre-Migration Build Verification (BLOCKING)
 
-**CRITICAL:** The backend MUST build successfully before creating a migration.
-EF Core tools compile the project internally; a build failure produces confusing errors
-that do not point to the actual source file.
-
-```bash
-dotnet build {SolutionName}.sln --no-restore
-```
-
-IF build fails:
-- Fix all compilation errors before proceeding
-- Common causes at this stage:
-  - Missing DbSet registration (should have been caught in step-04 Check 2)
-  - Missing DI registration (should have been caught in step-04 Check 3)
-  - Circular references between generated services
-  - Missing package references (e.g., FluentValidation)
-  - Frontend changes that modified shared files
-- Re-run build until successful
-- DO NOT attempt migration creation on a broken build
-
-**After build succeeds:** Continue to migration name suggestion.
+See [references/migration-checklist-troubleshooting.md](../references/migration-checklist-troubleshooting.md) for:
+- Build verification command
+- Common compilation causes
+- Fix strategies
+- Quick recovery commands
 
 ### 1. Get Migration Name Suggestion
 
@@ -103,29 +88,11 @@ dotnet ef migrations add {suggested_migration_name} --context ExtensionsDbContex
 
 ### 2b. Inject SQL Objects (if any exist)
 
-Check if any SQL object files exist:
-```
-Glob: **/Persistence/SqlObjects/Functions/*.sql
-```
-
-If SQL files are found, the migration's `Up()` method should include a call to re-apply all SQL objects:
-```csharp
-// At the end of the Up() method:
-SqlObjectHelper.ApplyAll(migrationBuilder);
-```
-
-This ensures SQL functions/views are re-applied with each migration (`CREATE OR ALTER` = idempotent).
+See [references/migration-checklist-troubleshooting.md](../references/migration-checklist-troubleshooting.md) for SQL Objects injection pattern.
 
 ### 3. Verify Migration Content
 
-The migration should include:
-- Navigation entity (Context/Application/Module/Section)
-- Navigation translations (4 languages)
-- Permissions (CRUD + wildcard)
-- RolePermissions (role assignments)
-- Domain entity table
-- Indexes and constraints
-- SQL Objects injection (if any .sql files exist)
+See [references/migration-checklist-troubleshooting.md](../references/migration-checklist-troubleshooting.md) for complete migration content verification checklist.
 
 ### 4. Apply Migration
 
@@ -205,26 +172,11 @@ dotnet ef database update --context ExtensionsDbContext
 
 ## TROUBLESHOOTING
 
-### Common Issues
-
-| Issue | Solution |
-|-------|----------|
-| Migration conflicts | Run `/efcore:conflicts` to analyze |
-| Permission 403 errors | Verify Permissions.cs and PermissionConfiguration.cs are in sync |
-| Navigation not visible | Check user role has appropriate permissions |
-| Route not found | Verify nested route structure in routes.tsx |
-| i18n missing | Check locale files exist and are properly loaded |
-
-### Quick Fixes
-
-```bash
-# Rebuild and restart
-dotnet build
-dotnet ef database update
-
-# Clear frontend cache
-cd web && rm -rf node_modules/.cache && npm run dev
-```
+See [references/migration-checklist-troubleshooting.md](../references/migration-checklist-troubleshooting.md) for:
+- Common issues and solutions
+- Quick fix commands
+- Database reset procedures
+- Final verification checklist
 
 ---
 

package/templates/skills/application/steps/step-07-tests.md

@@ -195,82 +195,15 @@ This generates:
 
 ## POST-GENERATION VERIFICATION (MANDATORY)
 
-### 1. Naming Convention Check (BLOCKING)
-
-All test methods MUST follow: `{Method}_When{Condition}_Should{Result}`
-
-```
-FORBIDDEN patterns:
-  Test1, Test2, TestMethod, MyTest
-  Should_Return_OK, test_get_all
-
-REQUIRED pattern:
-  GetAll_WhenCalled_ShouldReturn200WithList
-  Create_WhenDuplicateCode_ShouldThrowException
-  Delete_WhenNotAuthenticated_ShouldReturn401
-```
-
-### 2. Test Structure Check (BLOCKING)
-
-All tests MUST follow Arrange-Act-Assert:
-
-```csharp
-// CORRECT
-[Fact]
-public async Task GetById_WhenExists_ShouldReturn200()
-{
-    // Arrange
-    var id = Guid.NewGuid();
-    // ...
-
-    // Act
-    var response = await _client.GetAsync($"/api/{entityCode}/{id}");
-
-    // Assert
-    response.StatusCode.Should().Be(HttpStatusCode.OK);
-}
-```
-
-### 3. Dependencies Check (BLOCKING)
-
-Verify test project references:
-- `FluentAssertions` (NOT `Assert.Equal`)
-- `Moq` (NOT manual fakes)
-- `xunit` (NOT NUnit or MSTest)
-
-### 4. Coverage Check
-
-Minimum test coverage per category:
-
-| Category | Minimum Tests |
-|----------|---------------|
-| Controller (mock) | 10 (CRUD + auth + tenant) |
-| Controller (real integration) | 8 (CRUD + persistence + tenant isolation) |
-| Service | 8 (CRUD + errors) |
-| Entity | 5 (factory + update + validation) |
-| Validator | 8 (code + name + security) |
-| Repository | 8 (CRUD + tenant + pagination) |
-| Security | 10 (auth + injection + headers) |
-
-### 5. Build Check (BLOCKING)
-
-```bash
-dotnet build tests/{SolutionName}.Tests/{SolutionName}.Tests.csproj
-```
-
-If build fails, fix compilation errors before proceeding.
-
-### 6. Test Run (BLOCKING)
-
-```bash
-dotnet test tests/{SolutionName}.Tests/{SolutionName}.Tests.csproj --no-build --verbosity normal
-```
-
-**ALL tests MUST pass.** If tests fail:
-1. Read the failure output carefully
-2. Fix the failing tests or the code they test
-3. Re-run until all tests pass
-4. Do NOT proceed to the next step until all tests are green
+See [references/test-coverage-requirements.md](../references/test-coverage-requirements.md) for:
+- **Naming Convention Check** (BLOCKING) — `{Method}_When{Condition}_Should{Result}` pattern
+- **Test Structure Check** (BLOCKING) — Arrange-Act-Assert format
+- **Dependencies Check** (BLOCKING) — FluentAssertions, Moq, xunit
+- **Coverage Check** — Minimum tests per category (CRUD + auth + tenant + persistence + security)
+- **Build Check** (BLOCKING) — `dotnet build` must succeed
+- **Test Run** (BLOCKING) — `dotnet test` must pass 100%
+- **Real Integration Test Coverage** — DB persistence verification
+- **Security Test Categories** — OWASP coverage
 
 ---
 

package/templates/skills/application/templates-backend.md

@@ -9,35 +9,37 @@
 ```csharp
 // Add to src/SmartStack.Application/Common/Authorization/Permissions.cs
 
-public static class $CONTEXT_PASCAL
+public static class $APPLICATION_PASCAL
 {
-    public const string Access = "$context.$application";
+    public const string Access = "$application";
 
     public static class $MODULE_PASCAL
     {
-        public const string View = "$context.$application.$module.read";
-        public const string Create = "$context.$application.$module.create";
-        public const string Update = "$context.$application.$module.update";
-        public const string Delete = "$context.$application.$module.delete";
-        public const string Assign = "$context.$application.$module.assign";
-        public const string Execute = "$context.$application.$module.execute";
+        public const string View = "$application.$module.read";
+        public const string Create = "$application.$module.create";
+        public const string Update = "$application.$module.update";
+        public const string Delete = "$application.$module.delete";
+        public const string Assign = "$application.$module.assign";
+        public const string Execute = "$application.$module.execute";
     }
 }
 ```
 
-### Example for ERP > Sales > Products
+### Example for Sales > Products
 
 ```csharp
-public static class Erp
+public static class Sales
 {
-    public const string Access = "erp.sales";
+    public const string Access = "sales";
 
     public static class Products
     {
-        public const string View = "erp.sales.products.read";
-        public const string Create = "erp.sales.products.create";
-        public const string Update = "erp.sales.products.update";
-        public const string Delete = "erp.sales.products.delete";
+        public const string View = "sales.products.read";
+        public const string Create = "sales.products.create";
+        public const string Update = "sales.products.update";
+        public const string Delete = "sales.products.delete";
+        public const string Assign = "sales.products.assign";
+        public const string Execute = "sales.products.execute";
     }
 }
 ```
@@ -49,7 +51,7 @@ public static class Erp
 ```csharp
 // src/SmartStack.Application/Common/Interfaces/I{Module}Service.cs
 
-using SmartStack.Application.$CONTEXT_PASCAL.$APPLICATION_PASCAL.$MODULE_PASCAL.DTOs;
+using SmartStack.Application.$APPLICATION_PASCAL.$MODULE_PASCAL.DTOs;
 
 namespace SmartStack.Application.Common.Interfaces;
 
@@ -89,15 +91,15 @@ public interface I$MODULE_PASCALService
 > - NEVER use `Guid.Empty` as a placeholder — resolve the actual value from `_currentUser`
 
 ```csharp
-// src/SmartStack.Infrastructure/Services/$CONTEXT_PASCAL/$APPLICATION_PASCAL/$MODULE_PASCAL/$MODULE_PASCALService.cs
+// src/SmartStack.Infrastructure/Services/$APPLICATION_PASCAL/$MODULE_PASCAL/$MODULE_PASCALService.cs
 
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using SmartStack.Application.Common.Interfaces;
-using SmartStack.Application.$CONTEXT_PASCAL.$APPLICATION_PASCAL.$MODULE_PASCAL.DTOs;
-using SmartStack.Domain.$CONTEXT_PASCAL.$APPLICATION_PASCAL.$MODULE_PASCAL;
+using SmartStack.Application.$APPLICATION_PASCAL.$MODULE_PASCAL.DTOs;
+using SmartStack.Domain.$APPLICATION_PASCAL.$MODULE_PASCAL;
 
-namespace SmartStack.Infrastructure.Services.$CONTEXT_PASCAL.$APPLICATION_PASCAL.$MODULE_PASCAL;
+namespace SmartStack.Infrastructure.Services.$APPLICATION_PASCAL.$MODULE_PASCAL;
 
 public class $MODULE_PASCALService : I$MODULE_PASCALService
 {
@@ -280,9 +282,9 @@ public class $MODULE_PASCALService : I$MODULE_PASCALService
 ## TEMPLATE: DTOs
 
 ```csharp
-// src/SmartStack.Application/$CONTEXT_PASCAL/$APPLICATION_PASCAL/$MODULE_PASCAL/DTOs/$ENTITY_PASCALDto.cs
+// src/SmartStack.Application/$APPLICATION_PASCAL/$MODULE_PASCAL/DTOs/$ENTITY_PASCALDto.cs
 
-namespace SmartStack.Application.$CONTEXT_PASCAL.$APPLICATION_PASCAL.$MODULE_PASCAL.DTOs;
+namespace SmartStack.Application.$APPLICATION_PASCAL.$MODULE_PASCAL.DTOs;
 
 public record $ENTITY_PASCALDto
 {
@@ -321,11 +323,11 @@ public record $ENTITY_PASCALQueryParameters
 ## TEMPLATE: DOMAIN ENTITY
 
 ```csharp
-// src/SmartStack.Domain/$CONTEXT_PASCAL/$APPLICATION_PASCAL/$MODULE_PASCAL/$ENTITY_PASCAL.cs
+// src/SmartStack.Domain/$APPLICATION_PASCAL/$MODULE_PASCAL/$ENTITY_PASCAL.cs
 
 using SmartStack.Domain.Common;
 
-namespace SmartStack.Domain.$CONTEXT_PASCAL.$APPLICATION_PASCAL.$MODULE_PASCAL;
+namespace SmartStack.Domain.$APPLICATION_PASCAL.$MODULE_PASCAL;
 
 public class $ENTITY_PASCAL : BaseEntity
 {
@@ -370,13 +372,13 @@ public class $ENTITY_PASCAL : BaseEntity
 ## TEMPLATE: EF CONFIGURATION
 
 ```csharp
-// src/SmartStack.Infrastructure/Persistence/Configurations/$CONTEXT_PASCAL/$APPLICATION_PASCAL/$MODULE_PASCAL/$ENTITY_PASCALConfiguration.cs
+// src/SmartStack.Infrastructure/Persistence/Configurations/$APPLICATION_PASCAL/$MODULE_PASCAL/$ENTITY_PASCALConfiguration.cs
 
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
-using SmartStack.Domain.$CONTEXT_PASCAL.$APPLICATION_PASCAL.$MODULE_PASCAL;
+using SmartStack.Domain.$APPLICATION_PASCAL.$MODULE_PASCAL;
 
-namespace SmartStack.Infrastructure.Persistence.Configurations.$CONTEXT_PASCAL.$APPLICATION_PASCAL.$MODULE_PASCAL;
+namespace SmartStack.Infrastructure.Persistence.Configurations.$APPLICATION_PASCAL.$MODULE_PASCAL;
 
 public class $ENTITY_PASCALConfiguration : IEntityTypeConfiguration<$ENTITY_PASCAL>
 {