@atlashub/smartstack-cli 3.13.0 → 3.15.0

package/dist/mcp-entry.mjs

@@ -25799,6 +25799,7 @@ var init_types3 = __esm({
         "loc_",
         "lic_"
       ]),
+      customTablePrefixes: external_exports.array(external_exports.string()).default([]),
       scopeTypes: external_exports.array(external_exports.string()).default(["Core", "Extension", "Partner", "Community"]),
       migrationFormat: external_exports.string().default("{context}_v{version}_{sequence}_{Description}"),
       namespaces: external_exports.object({
@@ -25996,6 +25997,7 @@ var init_types3 = __esm({
         includeLayouts: external_exports.boolean().default(true).describe("Generate layout components"),
         includeGuards: external_exports.boolean().default(true).describe("Include route guards for permissions"),
         generateRegistry: external_exports.boolean().default(true).describe("Generate navRoutes.generated.ts"),
+        outputFormat: external_exports.enum(["standalone", "clientRoutes"]).default("standalone").describe('Output format: "standalone" generates createBrowserRouter(), "clientRoutes" generates exportable RouteObject[] arrays for App.tsx integration'),
         dryRun: external_exports.boolean().default(false).describe("Preview without writing files")
       }).optional()
     });
@@ -26356,6 +26358,7 @@ var init_config = __esm({
           "lic_",
           "tenant_"
         ],
+        customTablePrefixes: [],
         scopeTypes: ["Core", "Extension", "Partner", "Community"],
         migrationFormat: "{context}_v{version}_{sequence}_{Description}",
         namespaces: {
@@ -26698,7 +26701,7 @@ async function validateTablePrefixes(structure, config2, result) {
     cwd: structure.infrastructure
   });
   const validSchemas = [config2.conventions.schemas.platform, config2.conventions.schemas.extensions];
-  const validPrefixes = config2.conventions.tablePrefixes;
+  const validPrefixes = [...config2.conventions.tablePrefixes, ...config2.conventions.customTablePrefixes || []];
   const schemaConstantsMap = {
     "SchemaConstants.Core": config2.conventions.schemas.platform,
     "SchemaConstants.Extensions": config2.conventions.schemas.extensions
@@ -52579,7 +52582,8 @@ async function scaffoldControllerTests(name, options, testTypes, structure, conf
     });
   }
   result.instructions.push(`Add package reference: <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="9.*" />`);
-  result.instructions.push(`Add package reference: <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="9.*" />`);
+  result.instructions.push(`Add package reference: <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="9.*" />`);
+  result.instructions.push(`Add package reference: <PackageReference Include="Respawn" Version="4.*" />`);
 }
 async function scaffoldValidatorTests(name, options, testTypes, structure, config2, result, dryRun) {
   const testNamespace = `${config2.conventions.namespaces.application}.Tests`;
@@ -52631,7 +52635,8 @@ async function scaffoldRepositoryTests(name, options, testTypes, structure, conf
       type: "created"
     });
   }
-  result.instructions.push(`Add package reference: <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="8.*" />`);
+  result.instructions.push(`Add package reference: <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="9.*" />`);
+  result.instructions.push(`Add package reference: <PackageReference Include="Respawn" Version="4.*" />`);
 }
 async function scaffoldInfrastructureTests(name, options, structure, config2, result, dryRun) {
   const testNamespace = `${config2.conventions.namespaces.application}.Tests`;
@@ -52640,11 +52645,16 @@ async function scaffoldInfrastructureTests(name, options, structure, config2, re
     name,
     testNamespace,
     infrastructureNamespace,
+    applicationNamespace: config2.conventions.namespaces.application,
+    domainNamespace: config2.conventions.namespaces.domain,
     ...options
   };
   const templates = [
+    { template: databaseFixtureTemplate, filename: "DatabaseFixture.cs" },
+    { template: databaseCollectionTemplate, filename: "DatabaseCollection.cs" },
     { template: testFactoryTemplate, filename: "SmartStackTestFactory.cs" },
     { template: testAuthHandlerTemplate, filename: "TestAuthHandler.cs" },
+    { template: testTenantServiceTemplate, filename: "TestTenantService.cs" },
     { template: integrationTestBaseTemplate, filename: "IntegrationTestBase.cs" },
     { template: testDataSeederTemplate, filename: "TestDataSeeder.cs" }
   ];
@@ -52663,10 +52673,12 @@ async function scaffoldInfrastructureTests(name, options, structure, config2, re
     });
   }
   result.instructions.push(`Add package reference: <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="9.*" />`);
-  result.instructions.push(`Add package reference: <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="9.*" />`);
-  result.instructions.push(`Add package reference: <PackageReference Include="Microsoft.Data.Sqlite" Version="9.*" />`);
+  result.instructions.push(`Add package reference: <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="9.*" />`);
+  result.instructions.push(`Add package reference: <PackageReference Include="Microsoft.Data.SqlClient" Version="6.*" />`);
+  result.instructions.push(`Add package reference: <PackageReference Include="Respawn" Version="4.*" />`);
   result.instructions.push(`Add package reference: <PackageReference Include="FluentAssertions" Version="8.*" />`);
   result.instructions.push(`IMPORTANT: Add to your API .csproj: <InternalsVisibleTo Include="$(AssemblyName).Tests" /> or add 'public partial class Program { }' to Program.cs`);
+  result.instructions.push(`IMPORTANT: SQL Server LocalDB must be installed. Run 'sqllocaldb info MSSQLLocalDB' to verify.`);
 }
 function formatTestResult(result, _target, name, dryRun) {
   const lines = [];
@@ -52709,7 +52721,7 @@ function formatTestResult(result, _target, name, dryRun) {
   lines.push("");
   return lines.join("\n");
 }
-var import_handlebars2, scaffoldTestsTool, entityTestTemplate, serviceTestTemplate, controllerTestTemplate, validatorTestTemplate, repositoryTestTemplate, securityTestTemplate, testFactoryTemplate, testAuthHandlerTemplate, integrationTestBaseTemplate, testDataSeederTemplate, controllerIntegrationTestTemplate;
+var import_handlebars2, scaffoldTestsTool, entityTestTemplate, serviceTestTemplate, controllerTestTemplate, validatorTestTemplate, repositoryTestTemplate, securityTestTemplate, testFactoryTemplate, databaseFixtureTemplate, databaseCollectionTemplate, testTenantServiceTemplate, testAuthHandlerTemplate, integrationTestBaseTemplate, testDataSeederTemplate, controllerIntegrationTestTemplate;
 var init_scaffold_tests = __esm({
   "src/mcp/tools/scaffold-tests.ts"() {
     "use strict";
@@ -53676,6 +53688,7 @@ using System.Threading.Tasks;
 using FluentAssertions;
 using Microsoft.EntityFrameworkCore;
 using Xunit;
+using {{testNamespace}}.Integration;
 using {{infrastructureNamespace}}.Persistence;
 using {{infrastructureNamespace}}.Repositories;
 using {{domainNamespace}};
@@ -53683,30 +53696,35 @@ using {{domainNamespace}};
 namespace {{testNamespace}}.Integration.Repositories;
 
 /// <summary>
-/// Integration tests for {{name}}Repository
-/// Tests: CRUD with DbContext, Queries, Tenant scope
+/// Integration tests for {{name}}Repository against REAL SQL Server LocalDB.
+/// Uses DatabaseFixture for real migrations + Respawn for fast reset.
 /// </summary>
-public class {{name}}RepositoryTests : IDisposable
+[Collection(DatabaseCollection.Name)]
+public class {{name}}RepositoryTests : IAsyncLifetime
 {
-    private readonly ApplicationDbContext _context;
-    private readonly {{name}}Repository _repository;
+    private readonly DatabaseFixture _database;
+    private CoreDbContext _context = null!;
+    private {{name}}Repository _repository = null!;
 {{#unless isSystemEntity}}
-    private readonly Guid _tenantId = Guid.NewGuid();
+    private readonly Guid _tenantId = Guid.Parse("11111111-1111-1111-1111-111111111111");
 {{/unless}}
 
-    public {{name}}RepositoryTests()
+    public {{name}}RepositoryTests(DatabaseFixture database)
     {
-        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
-            .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
-            .Options;
+        _database = database;
+    }
 
-        _context = new ApplicationDbContext(options);
+    public async ValueTask InitializeAsync()
+    {
+        await _database.ResetDatabaseAsync();
+        _context = _database.CreateDbContext();
         _repository = new {{name}}Repository(_context);
     }
 
-    public void Dispose()
+    public async ValueTask DisposeAsync()
     {
-        _context.Dispose();
+        if (_context is not null)
+            await _context.DisposeAsync();
     }
 
     #region GetByIdAsync Tests
@@ -53754,9 +53772,10 @@ public class {{name}}RepositoryTests : IDisposable
         var result = await _repository.AddAsync(entity);
         await _context.SaveChangesAsync();
 
-        // Assert
+        // Assert \u2014 verify REAL SQL Server persistence
         result.Should().NotBeNull();
-        var persisted = await _context.Set<{{name}}>().FindAsync(entity.Id);
+        await using var verifyCtx = _database.CreateDbContext();
+        var persisted = await verifyCtx.Set<{{name}}>().FindAsync(entity.Id);
         persisted.Should().NotBeNull();
     }
 
@@ -53777,8 +53796,9 @@ public class {{name}}RepositoryTests : IDisposable
         await _repository.UpdateAsync(entity);
         await _context.SaveChangesAsync();
 
-        // Assert
-        var updated = await _context.Set<{{name}}>().FindAsync(entity.Id);
+        // Assert \u2014 verify REAL SQL Server persistence
+        await using var verifyCtx = _database.CreateDbContext();
+        var updated = await verifyCtx.Set<{{name}}>().FindAsync(entity.Id);
         updated!.UpdatedBy.Should().Be("updater");
     }
 
@@ -53798,15 +53818,16 @@ public class {{name}}RepositoryTests : IDisposable
         await _repository.DeleteAsync(entity);
         await _context.SaveChangesAsync();
 
-        // Assert
-        var deleted = await _context.Set<{{name}}>().FindAsync(entity.Id);
+        // Assert \u2014 verify REAL SQL Server deletion
+        await using var verifyCtx = _database.CreateDbContext();
+        var deleted = await verifyCtx.Set<{{name}}>().FindAsync(entity.Id);
         deleted.Should().BeNull();
     }
 
     #endregion
 
 {{#unless isSystemEntity}}
-    #region Tenant Isolation Tests
+    #region Tenant Isolation Tests (REAL SQL Server)
 
     [Fact]
     public async Task GetAllByTenantAsync_ShouldOnlyReturnTenantEntities()
@@ -53823,7 +53844,7 @@ public class {{name}}RepositoryTests : IDisposable
         // Act
         var result = await _repository.GetAllByTenantAsync(_tenantId);
 
-        // Assert
+        // Assert \u2014 tenant isolation enforced at SQL Server level
         result.Should().HaveCount(2);
         result.Should().OnlyContain(e => e.TenantId == _tenantId);
     }
@@ -53848,7 +53869,7 @@ public class {{name}}RepositoryTests : IDisposable
 {{/unless}}
 
 {{#if includeSoftDelete}}
-    #region Soft Delete Tests
+    #region Soft Delete Tests (REAL SQL Server)
 
     [Fact]
     public async Task GetAllAsync_ShouldExcludeSoftDeletedEntities()
@@ -53864,7 +53885,7 @@ public class {{name}}RepositoryTests : IDisposable
         // Act
         var result = await _repository.GetAllAsync();
 
-        // Assert
+        // Assert \u2014 soft delete filter verified at SQL Server level
         result.Should().ContainSingle();
         result.First().Code.Should().Be("active");
     }
@@ -54086,96 +54107,245 @@ public class {{name}}SecurityTests : IClassFixture<WebApplicationFactory<Program
     #endregion
 }
 `;
-    testFactoryTemplate = `using System;
-using System.Data.Common;
-using System.Linq;
-using Microsoft.AspNetCore.Authentication;
-using Microsoft.AspNetCore.Hosting;
+    testFactoryTemplate = `using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Mvc.Testing;
-using Microsoft.Data.Sqlite;
+using Microsoft.AspNetCore.TestHost;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using Microsoft.Extensions.Hosting;
 using {{infrastructureNamespace}}.Persistence;
 
 namespace {{testNamespace}}.Integration;
 
 /// <summary>
-/// Shared WebApplicationFactory for integration tests.
-/// Uses SQLite in-memory for real SQL behavior.
-/// Replaces JWT auth with TestAuthHandler.
+/// Custom WebApplicationFactory that redirects the API to use a test LocalDB database.
+/// Uses REAL SQL Server (LocalDB) \u2014 not SQLite. Validates real migrations, real LINQ\u2192SQL.
 /// </summary>
-public class SmartStackTestFactory : WebApplicationFactory<Program>, IAsyncLifetime
+public class SmartStackTestFactory : WebApplicationFactory<Program>
 {
-    private DbConnection _connection = null!;
+    private readonly string _connectionString;
 
-    protected override void ConfigureWebHost(IWebHostBuilder builder)
+    public SmartStackTestFactory(string connectionString)
     {
-        builder.ConfigureServices(services =>
+        _connectionString = connectionString;
+    }
+
+    protected override IHost CreateHost(IHostBuilder builder)
+    {
+        builder.ConfigureHostConfiguration(config =>
         {
-            // Remove existing DbContext registration
-            var dbDescriptor = services.SingleOrDefault(
-                d => d.ServiceType == typeof(DbContextOptions<ApplicationDbContext>));
-            if (dbDescriptor != null)
-                services.Remove(dbDescriptor);
-
-            // Remove existing DbConnection if registered
-            var connDescriptor = services.SingleOrDefault(
-                d => d.ServiceType == typeof(DbConnection));
-            if (connDescriptor != null)
-                services.Remove(connDescriptor);
-
-            // Create and open a shared SQLite in-memory connection
-            _connection = new SqliteConnection("DataSource=:memory:");
-            _connection.Open();
-
-            services.AddSingleton(_connection);
-            services.AddDbContext<ApplicationDbContext>((sp, options) =>
+            config.AddInMemoryCollection(new Dictionary<string, string?>
             {
-                options.UseSqlite(sp.GetRequiredService<DbConnection>());
+                ["ConnectionStrings:DefaultConnection"] = _connectionString,
+                ["Jwt:Secret"] = "IntegrationTestSecretKeyThatIsAtLeast256BitsLongForHmacSha256Validation!",
+                ["Jwt:Issuer"] = "SmartStack",
+                ["Jwt:Audience"] = "SmartStack",
+                ["Jwt:AccessTokenExpirationMinutes"] = "60",
             });
+        });
 
-            // Replace authentication with test handler
-            services.AddAuthentication("Test")
-                .AddScheme<AuthenticationSchemeOptions, TestAuthHandler>("Test", null);
+        return base.CreateHost(builder);
+    }
+
+    protected override void ConfigureWebHost(IWebHostBuilder builder)
+    {
+        builder.UseEnvironment("Development");
+
+        builder.ConfigureAppConfiguration((_, config) =>
+        {
+            config.AddInMemoryCollection(new Dictionary<string, string?>
+            {
+                ["ConnectionStrings:DefaultConnection"] = _connectionString,
+                ["Jwt:Secret"] = "IntegrationTestSecretKeyThatIsAtLeast256BitsLongForHmacSha256Validation!",
+                ["Jwt:Issuer"] = "SmartStack",
+                ["Jwt:Audience"] = "SmartStack",
+                ["Jwt:AccessTokenExpirationMinutes"] = "60",
+                ["Jwt:RefreshTokenExpirationDays"] = "7",
+            });
         });
 
-        builder.UseEnvironment("Testing");
+        builder.ConfigureTestServices(services =>
+        {
+            // Remove existing DbContext registrations
+            services.RemoveAll<DbContextOptions<CoreDbContext>>();
+
+            // Re-register with test SQL Server connection string
+            services.AddDbContext<CoreDbContext>(options =>
+            {
+                options.UseSqlServer(_connectionString, b =>
+                {
+                    b.MigrationsAssembly(typeof(CoreDbContext).Assembly.FullName);
+                });
+            });
+
+            services.AddScoped<ICoreDbContext>(provider =>
+                provider.GetRequiredService<CoreDbContext>());
+        });
     }
+}
+`;
+    databaseFixtureTemplate = `using System.Data.Common;
+using Microsoft.Data.SqlClient;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging.Abstractions;
+using Respawn;
+using {{applicationNamespace}}.Common.Interfaces.Tenants;
+using {{infrastructureNamespace}}.Persistence;
+
+namespace {{testNamespace}}.Integration;
+
+/// <summary>
+/// Shared fixture that manages a LocalDB test database lifecycle.
+/// Created once per test session, reset with Respawn between tests (~50ms).
+/// Applies REAL EF Core migrations \u2014 validates migration chain integrity.
+/// </summary>
+public class DatabaseFixture : IAsyncLifetime
+{
+    private const string LocalDbInstance = "MSSQLLocalDB";
+    private readonly string _databaseName = $"SmartStack_IntTests_{Guid.NewGuid():N}";
+    private Respawner _respawner = null!;
+    private DbConnection _connection = null!;
+
+    public string ConnectionString { get; private set; } = null!;
 
-    public async Task InitializeAsync()
+    public async ValueTask InitializeAsync()
     {
-        // Ensure database is created with current schema
-        using var scope = Services.CreateScope();
-        var db = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
-        await db.Database.EnsureCreatedAsync();
+        ConnectionString = $"Server=(localdb)\\\\{LocalDbInstance};Database={_databaseName};Integrated Security=true;TrustServerCertificate=true;Connect Timeout=120;";
 
-        // Seed minimal test data (tenant, admin user, base permissions)
-        var seeder = new TestDataSeeder(db);
-        await seeder.SeedAsync();
+        await CreateDatabaseAsync();
+        await ApplyMigrationsAsync();
+        await InitializeRespawnerAsync();
     }
 
-    async Task IAsyncLifetime.DisposeAsync()
+    public async ValueTask DisposeAsync()
     {
         if (_connection is not null)
-        {
-            await _connection.CloseAsync();
             await _connection.DisposeAsync();
-        }
+
+        await DropDatabaseAsync();
     }
 
     /// <summary>
-    /// Resets the database between test classes for isolation.
+    /// Resets all data in the test database (~50ms). Call before each test.
     /// </summary>
     public async Task ResetDatabaseAsync()
     {
-        using var scope = Services.CreateScope();
-        var db = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
-        await db.Database.EnsureDeletedAsync();
-        await db.Database.EnsureCreatedAsync();
+        await _respawner.ResetAsync(_connection);
+    }
+
+    /// <summary>
+    /// Creates a CoreDbContext connected to the test database.
+    /// Pass a tenantService to enable tenant query filters, or null for global scope.
+    /// </summary>
+    public CoreDbContext CreateDbContext(ICurrentTenantService? tenantService = null)
+    {
+        var options = new DbContextOptionsBuilder<CoreDbContext>()
+            .UseSqlServer(ConnectionString, b =>
+            {
+                b.MigrationsAssembly(typeof(CoreDbContext).Assembly.FullName);
+            })
+            .Options;
+
+        return new CoreDbContext(options, tenantService, null, NullLogger<CoreDbContext>.Instance);
+    }
+
+    private async Task CreateDatabaseAsync()
+    {
+        var masterCs = $"Server=(localdb)\\\\{LocalDbInstance};Database=master;Integrated Security=true;TrustServerCertificate=true;Connect Timeout=120;";
+        await using var conn = new SqlConnection(masterCs);
+        await conn.OpenAsync();
+
+        await using var cmd = conn.CreateCommand();
+        cmd.CommandText = $"CREATE DATABASE [{_databaseName}]";
+        await cmd.ExecuteNonQueryAsync();
+    }
+
+    private async Task ApplyMigrationsAsync()
+    {
+        await using var context = CreateDbContext();
+        await context.Database.MigrateAsync();
+    }
+
+    private async Task InitializeRespawnerAsync()
+    {
+        _connection = new SqlConnection(ConnectionString);
+        await _connection.OpenAsync();
+
+        _respawner = await Respawner.CreateAsync(_connection, new RespawnerOptions
+        {
+            DbAdapter = DbAdapter.SqlServer,
+            SchemasToInclude = ["core"],
+            TablesToIgnore = [new Respawn.Graph.Table("__EFMigrationsHistory")],
+            WithReseed = true
+        });
+    }
+
+    private async Task DropDatabaseAsync()
+    {
+        var masterCs = $"Server=(localdb)\\\\{LocalDbInstance};Database=master;Integrated Security=true;TrustServerCertificate=true;Connect Timeout=120;";
+        await using var conn = new SqlConnection(masterCs);
+        await conn.OpenAsync();
+
+        await using var cmd1 = conn.CreateCommand();
+        cmd1.CommandText = $"IF DB_ID('{_databaseName}') IS NOT NULL ALTER DATABASE [{_databaseName}] SET SINGLE_USER WITH ROLLBACK IMMEDIATE";
+        await cmd1.ExecuteNonQueryAsync();
+
+        await using var cmd2 = conn.CreateCommand();
+        cmd2.CommandText = $"IF DB_ID('{_databaseName}') IS NOT NULL DROP DATABASE [{_databaseName}]";
+        await cmd2.ExecuteNonQueryAsync();
+    }
+}
+`;
+    databaseCollectionTemplate = `namespace {{testNamespace}}.Integration;
+
+/// <summary>
+/// xUnit collection definition. All tests in this collection share the same DatabaseFixture.
+/// Database is created once, reset with Respawn between tests.
+/// </summary>
+[CollectionDefinition(Name)]
+public class DatabaseCollection : ICollectionFixture<DatabaseFixture>
+{
+    public const string Name = nameof(DatabaseCollection);
+}
+`;
+    testTenantServiceTemplate = `using {{applicationNamespace}}.Common.Interfaces.Tenants;
+using {{domainNamespace}}.Platform.Administration.Tenants;
+
+namespace {{testNamespace}}.Integration;
+
+/// <summary>
+/// Test implementation of ICurrentTenantService.
+/// Allows switching tenant context in tests to verify multi-tenant isolation.
+/// </summary>
+public class TestTenantService : ICurrentTenantService
+{
+    private Tenant? _tenant;
+    private bool _hasGlobalAccess;
+
+    public Guid? TenantId => _tenant?.Id;
+    public string? TenantSlug => _tenant?.Slug;
+    public Tenant? Tenant => _tenant;
+    public bool HasTenant => _tenant is not null;
+    public bool HasGlobalAccess => _hasGlobalAccess;
+    public bool IsGlobalScope => !HasTenant && HasGlobalAccess;
 
-        var seeder = new TestDataSeeder(db);
-        await seeder.SeedAsync();
+    public void SetTenant(Tenant? tenant) => _tenant = tenant;
+
+    public void SetGlobalAccess(bool hasGlobalAccess) => _hasGlobalAccess = hasGlobalAccess;
+
+    public void Clear()
+    {
+        _tenant = null;
+        _hasGlobalAccess = false;
     }
+
+    public Task<bool> SetBySlugAsync(string slug, CancellationToken cancellationToken = default)
+        => throw new NotImplementedException("Use SetTenant() directly in integration tests");
+
+    public Task<bool> SetByIdAsync(Guid tenantId, CancellationToken cancellationToken = default)
+        => throw new NotImplementedException("Use SetTenant() directly in integration tests");
 }
 `;
     testAuthHandlerTemplate = `using System.Security.Claims;
@@ -54245,6 +54415,7 @@ using System.Net.Http.Json;
 using System.Threading.Tasks;
 using FluentAssertions;
 using Microsoft.Extensions.DependencyInjection;
+using {{applicationNamespace}}.Common.Interfaces.Tenants;
 using {{infrastructureNamespace}}.Persistence;
 using Xunit;
 
@@ -54252,28 +54423,36 @@ namespace {{testNamespace}}.Integration;
 
 /// <summary>
 /// Base class for integration tests.
-/// Provides configured HttpClient with auth and tenant headers.
+/// Provides DatabaseFixture access, HttpClient with auth, and tenant switching.
+/// Uses REAL SQL Server LocalDB \u2014 not SQLite.
 /// </summary>
-public abstract class IntegrationTestBase : IClassFixture<SmartStackTestFactory>, IAsyncLifetime
+[Collection(DatabaseCollection.Name)]
+public abstract class IntegrationTestBase : IAsyncLifetime
 {
-    protected readonly SmartStackTestFactory Factory;
-    protected readonly HttpClient Client;
-    protected readonly Guid TestTenantId = TestAuthHandler.DefaultTenantId;
+    protected DatabaseFixture Database { get; }
+    protected SmartStackTestFactory Factory { get; }
+    protected HttpClient Client { get; }
+    protected static readonly Guid TestTenantId = Guid.Parse("11111111-1111-1111-1111-111111111111");
 
-    protected IntegrationTestBase(SmartStackTestFactory factory)
+    protected IntegrationTestBase(DatabaseFixture database)
     {
-        Factory = factory;
-        Client = factory.CreateClient();
+        Database = database;
+        Factory = new SmartStackTestFactory(database.ConnectionString);
+        Client = Factory.CreateClient();
         Client.DefaultRequestHeaders.Add("X-Tenant-Id", TestTenantId.ToString());
     }
 
-    public virtual async Task InitializeAsync()
+    public virtual async ValueTask InitializeAsync()
     {
-        // Reset database for each test class to ensure isolation
-        await Factory.ResetDatabaseAsync();
+        await Database.ResetDatabaseAsync();
     }
 
-    public virtual Task DisposeAsync() => Task.CompletedTask;
+    public virtual ValueTask DisposeAsync()
+    {
+        Client.Dispose();
+        Factory.Dispose();
+        return ValueTask.CompletedTask;
+    }
 
     /// <summary>
     /// Creates an HttpClient without authentication (for 401 tests).
@@ -54298,47 +54477,61 @@ public abstract class IntegrationTestBase : IClassFixture<SmartStackTestFactory>
 
     /// <summary>
     /// Gets direct access to the DbContext for verification queries.
+    /// Uses global scope (no tenant filter) for cross-tenant verification.
+    /// </summary>
+    protected async Task<T> WithDbContextAsync<T>(Func<CoreDbContext, Task<T>> action)
+    {
+        await using var context = Database.CreateDbContext();
+        return await action(context);
+    }
+
+    /// <summary>
+    /// Gets direct access to the DbContext with a specific tenant filter.
     /// </summary>
-    protected async Task<T> WithDbContextAsync<T>(Func<ApplicationDbContext, Task<T>> action)
+    protected async Task<T> WithTenantDbContextAsync<T>(Guid tenantId, Func<CoreDbContext, Task<T>> action)
     {
-        using var scope = Factory.Services.CreateScope();
-        var db = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
-        return await action(db);
+        var tenantService = new TestTenantService();
+        tenantService.SetTenant({{domainNamespace}}.Platform.Administration.Tenants.Tenant.CreateB2C("Test", "test"));
+        // Override the tenant ID
+        await using var context = Database.CreateDbContext(tenantService);
+        return await action(context);
     }
 }
 `;
     testDataSeederTemplate = `using System;
 using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore;
 using {{infrastructureNamespace}}.Persistence;
+using {{infrastructureNamespace}}.Persistence.Seeding;
 
 namespace {{testNamespace}}.Integration;
 
 /// <summary>
-/// Seeds minimal test data required for integration tests.
-/// Creates a test tenant, admin user, and base navigation/permissions.
+/// Seeds test data required for integration tests.
+/// Creates test tenant, admin user, base navigation, and permissions.
+/// Runs AFTER migrations are applied by DatabaseFixture.
 /// </summary>
 public class TestDataSeeder
 {
-    private readonly ApplicationDbContext _db;
+    private readonly CoreDbContext _db;
 
     public static readonly Guid TestTenantId = Guid.Parse("11111111-1111-1111-1111-111111111111");
     public static readonly Guid TestUserId = Guid.Parse("22222222-2222-2222-2222-222222222222");
 
-    public TestDataSeeder(ApplicationDbContext db)
+    public TestDataSeeder(CoreDbContext db)
     {
         _db = db;
     }
 
     public async Task SeedAsync()
     {
-        // NOTE: Add your tenant and user seeding logic here.
-        // This depends on your specific entity model.
-        // Example:
-        // var tenant = Tenant.Create("test-tenant", "Test Tenant");
-        // _db.Set<Tenant>().Add(tenant);
-        // await _db.SaveChangesAsync();
+        // Run core seeder (navigation, permissions, roles)
+        var coreSeeder = new DatabaseSeeder(_db);
+        await coreSeeder.SeedAsync();
 
-        await Task.CompletedTask;
+        // Run dev data seeder (test users, tenants, demo data)
+        var devSeeder = new DevDataSeeder(_db);
+        await devSeeder.SeedAsync();
     }
 }
 `;
@@ -54356,8 +54549,8 @@ namespace {{testNamespace}}.Integration.Controllers;
 
 /// <summary>
 /// REAL integration tests for {{name}}Controller.
-/// Uses actual DI pipeline, real services, SQLite database.
-/// No mocks - verifies the complete request/response cycle.
+/// Uses actual DI pipeline, real services, SQL Server LocalDB database.
+/// No mocks \u2014 verifies the complete request/response cycle against REAL SQL Server.
 /// </summary>
 public class {{name}}ControllerIntegrationTests : IntegrationTestBase
 {
@@ -56338,37 +56531,75 @@ async function scaffoldRoutes(input, config2) {
     }
     result.files.push({ path: registryFile, content: registryContent, type: "created" });
   }
-  const routerContent = generateRouterConfig(navRoutes, includeGuards);
-  const routerFile = path19.join(routesPath, "index.tsx");
-  if (!dryRun) {
-    await ensureDirectory(routesPath);
-    await writeText(routerFile, routerContent);
-  }
-  result.files.push({ path: routerFile, content: routerContent, type: "created" });
-  if (includeLayouts) {
-    const layoutsPath = path19.join(webPath, "src", "layouts");
-    const contexts = [...new Set(navRoutes.map((r) => r.navRoute.split(".")[0]))];
-    for (const context of contexts) {
-      const layoutContent = generateLayout(context);
-      const layoutFile = path19.join(layoutsPath, `${capitalize(context)}Layout.tsx`);
-      if (!dryRun) {
-        await ensureDirectory(layoutsPath);
-        await writeText(layoutFile, layoutContent);
-      }
-      result.files.push({ path: layoutFile, content: layoutContent, type: "created" });
+  const outputFormat = options?.outputFormat ?? "standalone";
+  if (outputFormat === "clientRoutes") {
+    const pageFiles = await discoverPageFiles(webPath, navRoutes);
+    const clientRoutesContent = generateClientRoutesConfig(navRoutes, pageFiles, includeGuards);
+    const clientRoutesFile = path19.join(routesPath, "clientRoutes.generated.tsx");
+    if (!dryRun) {
+      await ensureDirectory(routesPath);
+      await writeText(clientRoutesFile, clientRoutesContent);
     }
-  }
-  if (includeGuards) {
-    const guardsContent = generateRouteGuards();
-    const guardsFile = path19.join(routesPath, "guards.tsx");
+    result.files.push({ path: clientRoutesFile, content: clientRoutesContent, type: "created" });
+    result.instructions.push(`Generated ${navRoutes.length} routes in clientRoutes format`);
+    result.instructions.push("");
+    result.instructions.push("## App.tsx Wiring Instructions");
+    result.instructions.push("");
+    result.instructions.push("Import page components and add routes INSIDE the appropriate Layout wrapper in App.tsx.");
+    result.instructions.push("Routes must be added in BOTH the standard block and the tenant-prefixed block (/t/:slug/...).");
+    result.instructions.push("");
+    const routeTree = buildRouteTree(navRoutes);
+    for (const [context, applications] of Object.entries(routeTree)) {
+      const layoutName = getLayoutName(context);
+      result.instructions.push(`### ${capitalize(context)} context (inside <Route path="/${context}" element={<${layoutName} />}>):`);
+      result.instructions.push("");
+      result.instructions.push("```tsx");
+      for (const [, modules] of Object.entries(applications)) {
+        for (const route of modules) {
+          const modulePath = route.navRoute.split(".").slice(1).join("/");
+          const pageEntry = pageFiles.get(route.navRoute);
+          const component = pageEntry?.[0]?.componentName || `${route.navRoute.split(".").map(capitalize).join("")}Page`;
+          result.instructions.push(`<Route path="${modulePath}" element={<${component} />} />`);
+        }
+      }
+      result.instructions.push("```");
+      result.instructions.push("");
+      result.instructions.push("**IMPORTANT:** Also add the same routes inside the tenant-prefixed block (`/t/:slug/...`)");
+      result.instructions.push("");
+    }
+  } else {
+    const routerContent = generateRouterConfig(navRoutes, includeGuards);
+    const routerFile = path19.join(routesPath, "index.tsx");
     if (!dryRun) {
-      await writeText(guardsFile, guardsContent);
+      await ensureDirectory(routesPath);
+      await writeText(routerFile, routerContent);
+    }
+    result.files.push({ path: routerFile, content: routerContent, type: "created" });
+    if (includeLayouts) {
+      const layoutsPath = path19.join(webPath, "src", "layouts");
+      const contexts = [...new Set(navRoutes.map((r) => r.navRoute.split(".")[0]))];
+      for (const context of contexts) {
+        const layoutContent = generateLayout(context);
+        const layoutFile = path19.join(layoutsPath, `${capitalize(context)}Layout.tsx`);
+        if (!dryRun) {
+          await ensureDirectory(layoutsPath);
+          await writeText(layoutFile, layoutContent);
+        }
+        result.files.push({ path: layoutFile, content: layoutContent, type: "created" });
+      }
+    }
+    if (includeGuards) {
+      const guardsContent = generateRouteGuards();
+      const guardsFile = path19.join(routesPath, "guards.tsx");
+      if (!dryRun) {
+        await writeText(guardsFile, guardsContent);
+      }
+      result.files.push({ path: guardsFile, content: guardsContent, type: "created" });
     }
-    result.files.push({ path: guardsFile, content: guardsContent, type: "created" });
+    result.instructions.push(`Generated ${navRoutes.length} routes from ${source}`);
+    result.instructions.push('Import routes: import { router } from "./routes";');
+    result.instructions.push("Use with RouterProvider: <RouterProvider router={router} />");
   }
-  result.instructions.push(`Generated ${navRoutes.length} routes from ${source}`);
-  result.instructions.push('Import routes: import { router } from "./routes";');
-  result.instructions.push("Use with RouterProvider: <RouterProvider router={router} />");
   return result;
 }
 async function discoverNavRoutes(structure, scope) {
@@ -56764,6 +56995,157 @@ export const PermissionGuard: React.FC<PermissionGuardProps> = ({
 };
 `;
 }
+async function discoverPageFiles(webPath, routes) {
+  const pageMap = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const parts = route.navRoute.split(".");
+    const context = capitalize(parts[0]);
+    const app = capitalize(parts[1] || "default");
+    const moduleParts = parts.slice(2).map(capitalize);
+    const moduleDir = moduleParts.join("/");
+    const pagesDir = path19.join(webPath, "src", "pages", context, app, moduleDir || "");
+    try {
+      const pageFiles = await glob("*Page.tsx", { cwd: pagesDir, absolute: false });
+      if (pageFiles.length > 0) {
+        const entries = pageFiles.map((f) => {
+          const componentName = f.replace(".tsx", "");
+          const importPath = `@/pages/${context}/${app}/${moduleDir ? moduleDir + "/" : ""}${componentName}`;
+          return { importPath, componentName };
+        });
+        pageMap.set(route.navRoute, entries);
+      }
+    } catch {
+      logger.debug(`No pages found for route ${route.navRoute} at ${pagesDir}`);
+    }
+  }
+  return pageMap;
+}
+function generateClientRoutesConfig(routes, pageFiles, includeGuards) {
+  const routeTree = buildRouteTree(routes);
+  const lines = [
+    "/**",
+    " * Client Routes Configuration",
+    " *",
+    " * Auto-generated by SmartStack MCP - DO NOT EDIT MANUALLY",
+    ' * Run `scaffold_routes` with outputFormat: "clientRoutes" to regenerate.',
+    " *",
+    " * These routes must be added INSIDE the appropriate Layout wrapper in App.tsx.",
+    " * They are NOT standalone - they are children of the context layout routes.",
+    " * Routes must be added in BOTH the standard block and the tenant-prefixed block.",
+    " */",
+    "",
+    "import type { RouteObject } from 'react-router-dom';",
+    "import { Navigate } from 'react-router-dom';"
+  ];
+  if (includeGuards) {
+    lines.push("import { ROUTES } from './navRoutes.generated';");
+    lines.push("import { PermissionGuard } from './guards';");
+  }
+  lines.push("");
+  const importedComponents = /* @__PURE__ */ new Set();
+  for (const route of routes) {
+    const pageEntries = pageFiles.get(route.navRoute);
+    if (pageEntries) {
+      for (const entry of pageEntries) {
+        if (!importedComponents.has(entry.componentName)) {
+          lines.push(`import { ${entry.componentName} } from '${entry.importPath}';`);
+          importedComponents.add(entry.componentName);
+        }
+      }
+    }
+  }
+  for (const route of routes) {
+    if (!pageFiles.has(route.navRoute)) {
+      const pageName = route.navRoute.split(".").map(capitalize).join("") + "Page";
+      lines.push(`// TODO: import { ${pageName} } from '@/pages/...';`);
+    }
+  }
+  lines.push("");
+  for (const [context, applications] of Object.entries(routeTree)) {
+    const contextUpper = capitalize(context);
+    const layoutName = getLayoutName(context);
+    lines.push("/**");
+    lines.push(` * Routes for ${contextUpper} context`);
+    lines.push(` * Add these as children of <Route path="/${context}" element={<${layoutName} />}>`);
+    lines.push(" */");
+    lines.push(`export const ${context}Routes: RouteObject[] = [`);
+    for (const [app, modules] of Object.entries(applications)) {
+      if (modules.length > 1) {
+        lines.push("  {");
+        lines.push(`    path: '${app}',`);
+        lines.push("    children: [");
+        const firstModulePath = modules[0].navRoute.split(".").slice(2).join("/");
+        lines.push(`      { index: true, element: <Navigate to="${firstModulePath}" replace /> },`);
+        for (const route of modules) {
+          const modulePath = route.navRoute.split(".").slice(2).join("/");
+          const pageName = route.navRoute.split(".").map(capitalize).join("") + "Page";
+          const pageEntry = pageFiles.get(route.navRoute);
+          const component = pageEntry?.[0]?.componentName || pageName;
+          const hasRealPage = pageFiles.has(route.navRoute);
+          if (includeGuards && route.permissions.length > 0) {
+            lines.push(`      {`);
+            lines.push(`        path: '${modulePath}',`);
+            if (hasRealPage) {
+              lines.push(`        element: <PermissionGuard permissions={ROUTES['${route.navRoute}'].permissions}><${component} /></PermissionGuard>,`);
+            } else {
+              lines.push(`        element: <PermissionGuard permissions={ROUTES['${route.navRoute}'].permissions}><div>TODO: ${component}</div></PermissionGuard>,`);
+            }
+            lines.push(`      },`);
+          } else {
+            lines.push(`      {`);
+            lines.push(`        path: '${modulePath}',`);
+            lines.push(`        element: ${hasRealPage ? `<${component} />` : `<div>TODO: ${component}</div>`},`);
+            lines.push(`      },`);
+          }
+        }
+        lines.push("    ],");
+        lines.push("  },");
+      } else {
+        for (const route of modules) {
+          const fullPath = route.navRoute.split(".").slice(1).join("/");
+          const pageName = route.navRoute.split(".").map(capitalize).join("") + "Page";
+          const pageEntry = pageFiles.get(route.navRoute);
+          const component = pageEntry?.[0]?.componentName || pageName;
+          const hasRealPage = pageFiles.has(route.navRoute);
+          if (includeGuards && route.permissions.length > 0) {
+            lines.push(`  {`);
+            lines.push(`    path: '${fullPath}',`);
+            if (hasRealPage) {
+              lines.push(`    element: <PermissionGuard permissions={ROUTES['${route.navRoute}'].permissions}><${component} /></PermissionGuard>,`);
+            } else {
+              lines.push(`    element: <PermissionGuard permissions={ROUTES['${route.navRoute}'].permissions}><div>TODO: ${component}</div></PermissionGuard>,`);
+            }
+            lines.push(`  },`);
+          } else {
+            lines.push(`  {`);
+            lines.push(`    path: '${fullPath}',`);
+            lines.push(`    element: ${hasRealPage ? `<${component} />` : `<div>TODO: ${component}</div>`},`);
+            lines.push(`  },`);
+          }
+        }
+      }
+    }
+    lines.push("];");
+    lines.push("");
+  }
+  const contexts = Object.keys(routeTree);
+  lines.push("/** All generated routes grouped by context */");
+  lines.push("export const generatedRoutes = {");
+  for (const context of contexts) {
+    lines.push(`  ${context}: ${context}Routes,`);
+  }
+  lines.push("};");
+  lines.push("");
+  return lines.join("\n");
+}
+function getLayoutName(context) {
+  const layoutMap = {
+    platform: "AdminLayout",
+    business: "BusinessLayout",
+    personal: "UserLayout"
+  };
+  return layoutMap[context] || `${capitalize(context)}Layout`;
+}
 function capitalize(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
@@ -56848,6 +57230,7 @@ and generates corresponding frontend routing infrastructure.`,
               includeLayouts: { type: "boolean", default: true },
               includeGuards: { type: "boolean", default: true },
               generateRegistry: { type: "boolean", default: true },
+              outputFormat: { type: "string", enum: ["standalone", "clientRoutes"], default: "standalone", description: "standalone: createBrowserRouter(), clientRoutes: RouteObject[] arrays for App.tsx" },
               dryRun: { type: "boolean", default: false }
             }
           }
@@ -56883,6 +57266,12 @@ async function validateFrontendRoutes(input, config2) {
       orphaned: [],
       missing: []
     },
+    appWiring: {
+      exists: false,
+      routesImported: false,
+      routeFileChecked: "",
+      issues: []
+    },
     recommendations: []
   };
   const { scope } = input;
@@ -56899,8 +57288,11 @@ async function validateFrontendRoutes(input, config2) {
   if (scope === "all" || scope === "routes") {
     await validateRoutes(webPath, backendRoutes, result);
   }
+  if (scope === "all" || scope === "routes") {
+    await validateAppWiring(webPath, backendRoutes, result);
+  }
   generateRecommendations2(result);
-  result.valid = result.apiClients.issues.filter((i) => i.severity === "error").length === 0 && result.routes.missing.length === 0 && result.registry.exists;
+  result.valid = result.apiClients.issues.filter((i) => i.severity === "error").length === 0 && result.routes.missing.length === 0 && result.registry.exists && result.appWiring.issues.length === 0;
   return result;
 }
 async function discoverBackendNavRoutes(structure) {
@@ -57072,6 +57464,51 @@ async function validateRoutes(webPath, backendRoutes, result) {
     result.routes.missing = backendRoutes.map((r) => r.navRoute);
   }
 }
+async function validateAppWiring(webPath, backendRoutes, result) {
+  const appCandidates = ["App.tsx", "main.tsx"];
+  let appFilePath = null;
+  let appContent = "";
+  for (const candidate of appCandidates) {
+    const candidatePath = path20.join(webPath, "src", candidate);
+    if (await fileExists(candidatePath)) {
+      appFilePath = candidatePath;
+      try {
+        appContent = await readText(candidatePath);
+      } catch {
+        logger.debug(`Failed to read ${candidatePath}`);
+      }
+      break;
+    }
+  }
+  result.appWiring = {
+    exists: !!appFilePath,
+    routesImported: false,
+    routeFileChecked: appFilePath || "",
+    issues: []
+  };
+  if (!appFilePath || !appContent) {
+    result.appWiring.issues.push("No App.tsx or main.tsx found in web/src/");
+    return;
+  }
+  const hasClientRoutesImport = appContent.includes("clientRoutes.generated");
+  const hasRoutesImport = appContent.includes("from './routes") || appContent.includes("from '../routes");
+  const hasInlineRoutes = appContent.includes("<Route ");
+  result.appWiring.routesImported = hasClientRoutesImport || hasRoutesImport || hasInlineRoutes;
+  if (!result.appWiring.routesImported) {
+    result.appWiring.issues.push("App.tsx does not import any route configuration");
+    return;
+  }
+  for (const route of backendRoutes) {
+    const modulePath = route.navRoute.split(".").slice(1).join("/");
+    const lastSegment = route.navRoute.split(".").pop() || "";
+    const pathInApp = appContent.includes(`path="${modulePath}"`) || appContent.includes(`path='${modulePath}'`) || appContent.includes(`path="${lastSegment}"`) || appContent.includes(`path='${lastSegment}'`);
+    if (!pathInApp) {
+      result.appWiring.issues.push(
+        `Route "${route.navRoute}" (path: ${modulePath}) not wired in App.tsx`
+      );
+    }
+  }
+}
 function generateRecommendations2(result) {
   if (!result.registry.exists) {
     result.recommendations.push('Run `scaffold_routes source="controllers"` to generate route registry');
@@ -57094,6 +57531,14 @@ function generateRecommendations2(result) {
   if (result.routes.orphaned.length > 0) {
     result.recommendations.push(`${result.routes.orphaned.length} frontend routes have no backend NavRoute`);
   }
+  if (result.appWiring && !result.appWiring.exists) {
+    result.recommendations.push("No App.tsx found. Create App.tsx with route configuration.");
+  } else if (result.appWiring && result.appWiring.issues.length > 0) {
+    const unwired = result.appWiring.issues.filter((i) => i.includes("not wired")).length;
+    if (unwired > 0) {
+      result.recommendations.push(`${unwired} backend routes not wired in App.tsx. Add <Route> entries inside Layout wrappers.`);
+    }
+  }
   if (result.valid && result.recommendations.length === 0) {
     result.recommendations.push("All routes are synchronized between frontend and backend");
   }
@@ -57159,6 +57604,26 @@ function formatResult6(result, _input) {
     }
     lines.push("");
   }
+  if (result.appWiring) {
+    lines.push("## App.tsx Wiring");
+    lines.push("");
+    lines.push("| Check | Status |");
+    lines.push("|-------|--------|");
+    lines.push(`| App file exists | ${result.appWiring.exists ? "Yes" : "No"} |`);
+    lines.push(`| Routes imported | ${result.appWiring.routesImported ? "Yes" : "No"} |`);
+    if (result.appWiring.routeFileChecked) {
+      lines.push(`| File checked | ${path20.basename(result.appWiring.routeFileChecked)} |`);
+    }
+    lines.push("");
+    if (result.appWiring.issues.length > 0) {
+      lines.push("### Wiring Issues");
+      lines.push("");
+      for (const issue2 of result.appWiring.issues) {
+        lines.push(`- ${issue2}`);
+      }
+      lines.push("");
+    }
+  }
   lines.push("## Recommendations");
   lines.push("");
   for (const rec of result.recommendations) {
@@ -63063,6 +63528,26 @@ Tables are organized by domain using prefixes:
 | \`lic_\` | Licensing | lic_Licenses |
 | \`tenant_\` | Multi-Tenancy | tenant_Tenants, tenant_TenantUsers, tenant_TenantUserRoles |
 
+### Custom Application Prefixes
+
+In addition to the platform prefixes above, client applications define their own table prefix during business analysis (\`/business-analyse\` cadrage phase). This prefix identifies which business application a table belongs to.
+
+**Format:** \`{2-5 lowercase letters}_\` (e.g., \`rh_\`, \`fi_\`, \`crm_\`, \`sales_\`)
+
+**Examples:**
+
+| Application | Prefix | Example Tables |
+|-------------|--------|----------------|
+| Human Resources | \`rh_\` | rh_Employees, rh_Contracts, rh_LeaveRequests |
+| Finance | \`fi_\` | fi_Invoices, fi_Payments, fi_BudgetLines |
+| CRM | \`crm_\` | crm_Contacts, crm_Opportunities, crm_Campaigns |
+
+**Rules:**
+1. Defined once per application in \`feature.json\` (\`metadata.tablePrefix\`)
+2. All entities in the application use the same prefix
+3. Must not collide with platform prefixes (auth_, nav_, etc.)
+4. Registered in MCP config via \`conventions.customTablePrefixes\` for validation
+
 ### Navigation Scope System
 
 All navigation data (Context, Application, Module, Section) uses a **Scope** field to distinguish system data from client extensions: