@atlashub/smartstack-cli 3.37.0 → 3.39.0

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

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

@@ -8,11 +8,11 @@
 
 ```
 web/smartstack-web/src/
-├── pages/$CONTEXT/$APPLICATION/$MODULE/
+├── pages/$APPLICATION/$MODULE/
 │   ├── $MODULE_PASCALPage.tsx          # Main page (list)
 │   ├── $MODULE_PASCALDetailPage.tsx    # Detail page
 │   └── Create$MODULE_PASCALPage.tsx    # Create page
-├── components/$CONTEXT/$MODULE/
+├── components/$APPLICATION/$MODULE/
 │   ├── $MODULE_PASCALListView.tsx      # Reusable list component
 │   ├── $MODULE_PASCALForm.tsx          # CRUD form
 │   └── $MODULE_PASCALFilters.tsx       # Filters
@@ -55,10 +55,10 @@ Examples:
 ## TEMPLATE: MAIN PAGE
 
 ```tsx
-// pages/$CONTEXT/$APPLICATION/$MODULE/$MODULE_PASCALPage.tsx
+// pages/$APPLICATION/$MODULE/$MODULE_PASCALPage.tsx
 
 import { useTranslation } from 'react-i18next';
-import { $MODULE_PASCALListView } from '@/components/$CONTEXT/$MODULE/$MODULE_PASCALListView';
+import { $MODULE_PASCALListView } from '@/components/$APPLICATION/$MODULE/$MODULE_PASCALListView';
 
 export function $MODULE_PASCALPage() {
   const { t } = useTranslation(['$module', 'common']);
@@ -78,7 +78,7 @@ export function $MODULE_PASCALPage() {
 ## TEMPLATE: LIST VIEW (Reusable component)
 
 ```tsx
-// components/$CONTEXT/$MODULE/$MODULE_PASCALListView.tsx
+// components/$APPLICATION/$MODULE/$MODULE_PASCALListView.tsx
 
 import { useState, useEffect } from 'react';
 import { useNavigate } from 'react-router-dom';
@@ -511,78 +511,78 @@ Before adding routes, **read App.tsx** and detect which pattern is used:
 
 | Pattern | How to detect | Action |
 |---------|---------------|--------|
-| **Pattern A** (mergeRoutes) | `contextRoutes: ContextRouteExtensions` present | Add to `contextRoutes.{context}[]` array |
-| **Pattern B** (JSX Routes) | `<Route path="/{context}" element={<{Layout} />}>` present | Insert `<Route>` children inside Layout wrapper |
+| **Pattern A** (mergeRoutes) | `applicationRoutes: ApplicationRouteExtensions` present | Add to `applicationRoutes.{application}[]` array |
+| **Pattern B** (JSX Routes) | `<Route path="/{application}" element={<{Layout} />}>` present | Insert `<Route>` children inside Layout wrapper |
 
-### Pattern A: mergeRoutes (contextRoutes array)
+### Pattern A: mergeRoutes (applicationRoutes array)
 
 > **This is the DEFAULT pattern** generated by `smartstack init`.
-> Routes added to `contextRoutes` are automatically injected into BOTH standard and tenant-prefixed route trees by `mergeRoutes()`. No manual duplication needed.
+> Routes added to `applicationRoutes` are automatically injected into BOTH standard and tenant-prefixed route trees by `mergeRoutes()`. No manual duplication needed.
 
 ```tsx
 // Add to App.tsx — imports at top
-import { $MODULE_PASCALPage } from '@/pages/$CONTEXT/$APPLICATION/$MODULE/$MODULE_PASCALPage';
-import { $MODULE_PASCALDetailPage } from '@/pages/$CONTEXT/$APPLICATION/$MODULE/$MODULE_PASCALDetailPage';
-import { Create$MODULE_PASCALPage } from '@/pages/$CONTEXT/$APPLICATION/$MODULE/Create$MODULE_PASCALPage';
+import { $MODULE_PASCALPage } from '@/pages/$APPLICATION/$MODULE/$MODULE_PASCALPage';
+import { $MODULE_PASCALDetailPage } from '@/pages/$APPLICATION/$MODULE/$MODULE_PASCALDetailPage';
+import { Create$MODULE_PASCALPage } from '@/pages/$APPLICATION/$MODULE/Create$MODULE_PASCALPage';
 
-// Add routes to contextRoutes.{context}[] with RELATIVE paths (no leading /)
-const contextRoutes: ContextRouteExtensions = {
-  $CONTEXT: [
+// Add routes to applicationRoutes.{application}[] with RELATIVE paths (no leading /)
+const applicationRoutes: ApplicationRouteExtensions = {
+  $APPLICATION: [
     // ... existing routes ...
-    { path: '$APPLICATION_KEBAB/$MODULE_KEBAB', element: <$MODULE_PASCALPage /> },
-    { path: '$APPLICATION_KEBAB/$MODULE_KEBAB/new', element: <Create$MODULE_PASCALPage /> },
-    { path: '$APPLICATION_KEBAB/$MODULE_KEBAB/:id', element: <$MODULE_PASCALDetailPage /> },
-    { path: '$APPLICATION_KEBAB/$MODULE_KEBAB/:id/edit', element: <Create$MODULE_PASCALPage /> },
+    { path: '$MODULE_KEBAB', element: <$MODULE_PASCALPage /> },
+    { path: '$MODULE_KEBAB/new', element: <Create$MODULE_PASCALPage /> },
+    { path: '$MODULE_KEBAB/:id', element: <$MODULE_PASCALDetailPage /> },
+    { path: '$MODULE_KEBAB/:id/edit', element: <Create$MODULE_PASCALPage /> },
   ],
 };
 ```
 
-**mergeRoutes auto-generates redirects** for intermediate paths (e.g., `$APPLICATION_KEBAB` → `$APPLICATION_KEBAB/$DEFAULT_MODULE_KEBAB`) so you don't need to add index redirects manually.
+**mergeRoutes auto-generates redirects** for intermediate paths (e.g., `$APPLICATION` → `$APPLICATION/$DEFAULT_MODULE_KEBAB`) so you don't need to add index redirects manually.
 
-**Context-to-Layout mapping (automatic via mergeRoutes):**
+**Application-to-Layout mapping (automatic via mergeRoutes):**
 
-| Context key | Injected into Layout | Standard path | Tenant path |
-|-------------|---------------------|---------------|-------------|
-| `platform` | `AdminLayout` | `/platform/...` | `/t/:slug/platform/...` |
-| `business` | `BusinessLayout` | `/business/...` | `/t/:slug/business/...` |
-| `personal` | `UserLayout` | `/personal/myspace/...` | `/t/:slug/personal/myspace/...` |
+| Application key | Injected into Layout | Standard path | Tenant path |
+|-----------------|---------------------|---------------|-------------|
+| `administration` | `AppLayout` | `/administration/...` | `/t/:slug/administration/...` |
+| `{application}` | `AppLayout` | `/{application}/...` | `/t/:slug/{application}/...` |
+| `myspace` | `AppLayout` | `/myspace/...` | `/t/:slug/myspace/...` |
 
 ### Pattern B: JSX Routes (inside Layout wrapper)
 
 > **Legacy pattern** — only used if App.tsx was manually restructured with JSX `<Route>` elements.
 
-SmartStack layouts (`AdminLayout`, `BusinessLayout`, `UserLayout`) provide the application shell: **header with AvatarMenu**, sidebar, navigation. They render child pages via React Router's `<Outlet />`.
+The unified `AppLayout` provides the application shell: **header with AvatarMenu**, sidebar, navigation. It renders child pages via React Router's `<Outlet />`.
 
 **If routes are placed OUTSIDE the layout wrapper, the shell (header, sidebar, AvatarMenu) will NOT render. The page appears "naked" without any navigation.**
 
 **Step-by-step insertion:**
 
 1. Open `App.tsx`
-2. Find the existing layout route for the target context:
-   - `platform` → `<Route path="/platform" element={<AdminLayout />}>`
-   - `business` → `<Route path="/business" element={<BusinessLayout />}>`
-   - `personal` → `<Route path="/personal/myspace" element={<UserLayout />}>`
+2. Find the existing layout route for the target application:
+   - `administration` → `<Route path="/administration" element={<AppLayout />}>`
+   - `{application}` → `<Route path="/{application}" element={<AppLayout />}>`
+   - `myspace` → `<Route path="/myspace" element={<AppLayout />}>`
 3. Add the new routes **INSIDE** that `<Route>` block
 4. If a tenant-prefixed block exists (`/t/:slug/...`), add the routes there too
 
 ```tsx
 // Add to App.tsx
 
-import { $MODULE_PASCALPage } from '@/pages/$CONTEXT/$APPLICATION/$MODULE/$MODULE_PASCALPage';
-import { $MODULE_PASCALDetailPage } from '@/pages/$CONTEXT/$APPLICATION/$MODULE/$MODULE_PASCALDetailPage';
-import { Create$MODULE_PASCALPage } from '@/pages/$CONTEXT/$APPLICATION/$MODULE/Create$MODULE_PASCALPage';
+import { $MODULE_PASCALPage } from '@/pages/$APPLICATION/$MODULE/$MODULE_PASCALPage';
+import { $MODULE_PASCALDetailPage } from '@/pages/$APPLICATION/$MODULE/$MODULE_PASCALDetailPage';
+import { Create$MODULE_PASCALPage } from '@/pages/$APPLICATION/$MODULE/Create$MODULE_PASCALPage';
 
 // Find the EXISTING layout route and add routes INSIDE it:
-<Route path="/$CONTEXT" element={<$CONTEXT_Layout />}>
+<Route path="/$APPLICATION" element={<$APPLICATION_Layout />}>
   {/* ... existing routes stay here ... */}
 
-  {/* NEW: $APPLICATION routes - added as children of the layout */}
-  <Route path="$APPLICATION_KEBAB">
-    <Route index element={<Navigate to="$DEFAULT_MODULE_KEBAB" replace />} />
-    <Route path="$MODULE_KEBAB" element={<$MODULE_PASCALPage />} />
-    <Route path="$MODULE_KEBAB/new" element={<Create$MODULE_PASCALPage />} />
-    <Route path="$MODULE_KEBAB/:id" element={<$MODULE_PASCALDetailPage />} />
-    <Route path="$MODULE_KEBAB/:id/edit" element={<Create$MODULE_PASCALPage />} />
+  {/* NEW: $MODULE routes - added as children of the layout */}
+  <Route path="$MODULE_KEBAB">
+    <Route index element={<Navigate to="." replace />} />
+    <Route index element={<$MODULE_PASCALPage />} />
+    <Route path="new" element={<Create$MODULE_PASCALPage />} />
+    <Route path=":id" element={<$MODULE_PASCALDetailPage />} />
+    <Route path=":id/edit" element={<Create$MODULE_PASCALPage />} />
   </Route>
 </Route>
 ```
@@ -593,22 +593,22 @@ import { Create$MODULE_PASCALPage } from '@/pages/$CONTEXT/$APPLICATION/$MODULE/
 ```tsx
 // ❌ WRONG — bypasses layout entirely, shell will NOT render
 const clientRoutes: RouteConfig[] = [
-  { path: '/business/$APPLICATION_KEBAB/$MODULE_KEBAB', element: <$MODULE_PASCALPage /> },
+  { path: '/$APPLICATION_KEBAB/$MODULE_KEBAB', element: <$MODULE_PASCALPage /> },
 ];
 ```
 
-`clientRoutes` is ONLY for routes **outside** SmartStack locked contexts (e.g., `/about`, `/pricing`).
+`clientRoutes` is ONLY for routes **outside** SmartStack locked applications (e.g., `/about`, `/pricing`).
 
 **FORBIDDEN — Flat routes outside layout:**
 ```tsx
 // ❌ WRONG (Pattern B only) — flat route bypasses layout
-<Route path="/$CONTEXT/$APPLICATION_KEBAB/$MODULE_KEBAB" element={<$MODULE_PASCALPage />} />
+<Route path="/$APPLICATION_KEBAB/$MODULE_KEBAB" element={<$MODULE_PASCALPage />} />
 ```
 
 ### Why nested/context routes?
 
-| Aspect | clientRoutes (wrong) | contextRoutes / nested (correct) |
-|--------|---------------------|----------------------------------|
+| Aspect | clientRoutes (wrong) | applicationRoutes / nested (correct) |
+|--------|---------------------|--------------------------------------|
 | Shell rendered | No (bypasses layout) | Yes (Outlet pattern) |
 | AvatarMenu visible | No | Yes |
 | Tenant prefix | Manual duplication | Automatic (mergeRoutes) |
@@ -628,7 +628,7 @@ These patterns are **strictly prohibited** in generated frontend code:
 | Any hardcoded Tailwind color (`bg-{color}-{shade}`) | CSS variables from style-guide.md |
 | `rounded-lg`, `rounded-md` | `rounded-[var(--radius-card)]`, `rounded-[var(--radius-button)]` |
 | Custom `<div>` cards for entity lists | `<EntityCard>` component (MANDATORY) |
-| Flat routes outside Layout wrapper | Nested routes inside `<BusinessLayout>` / `<AdminLayout>` |
+| Flat routes outside Layout wrapper | Nested routes inside Layout wrapper |
 | Route paths with PascalCase or concatenated words (e.g., `humanresources`, `timeManagement`) | Kebab-case route paths (e.g., `human-resources`, `time-management`) |
 | `navigate(\`${basePath}/${item.id}\`)` in list row click | `navigate(item.id)` (relative navigation, no path duplication) |
 | Only 2 languages (fr/en) | All 4 languages (fr/en/it/de) |
@@ -649,7 +649,7 @@ These patterns are **strictly prohibited** in generated frontend code:
 | ☐ Preferences hook created (`use$MODULE_PASCALPreferences.ts`) | |
 | ☐ API service created (uses `apiClient`, NOT raw axios) | |
 | ☐ Routes added inside Layout wrapper in App.tsx | |
-| ☐ Route path follows `/{context}/{application_kebab}/{module_kebab}` (kebab-case) | |
+| ☐ Route path follows `/{application_kebab}/{module_kebab}` (kebab-case) | |
 
 ### Theme Compliance
 | Check | Status |