@atlashub/smartstack-cli 3.31.0 → 3.32.0

package/dist/mcp-entry.mjs

@@ -25763,7 +25763,31 @@ var init_zod = __esm({
 });
 
 // src/mcp/types/index.ts
-var ProjectConfigSchema, SmartStackConfigSchema, ConventionsConfigSchema, EfCoreContextSchema, EfCoreConfigSchema, ScaffoldingConfigSchema, ConfigSchema, ValidateConventionsInputSchema, CheckMigrationsInputSchema, EntityPropertySchema, ScaffoldExtensionInputSchema, ApiDocsInputSchema, SuggestMigrationInputSchema, GeneratePermissionsInputSchema, TestTypeSchema, TestTargetSchema, ScaffoldTestsInputSchema, AnalyzeTestCoverageInputSchema, ValidateTestConventionsInputSchema, SuggestTestScenariosInputSchema, SecurityCheckSchema, ValidateSecurityInputSchema, QualityMetricSchema, AnalyzeCodeQualityInputSchema, ScaffoldApiClientInputSchema, ScaffoldRoutesInputSchema, ValidateFrontendRoutesInputSchema, SlotDefinitionSchema, ScaffoldFrontendExtensionInputSchema, AnalyzeExtensionPointsInputSchema, AnalyzeHierarchyPatternsInputSchema, ReviewCodeCheckSchema, ReviewCodeInputSchema;
+function resolveTenantMode(options) {
+  if (options?.tenantMode) return options.tenantMode;
+  if (options?.isSystemEntity === true) return "none";
+  return "strict";
+}
+function tenantModeToTemplateFlags(mode) {
+  return {
+    // Backward compat — existing templates use {{#unless isSystemEntity}}
+    isSystemEntity: mode === "none",
+    // Mode-specific flags
+    isStrict: mode === "strict",
+    isOptional: mode === "optional",
+    isScoped: mode === "scoped",
+    isNone: mode === "none",
+    // Derived flags for cleaner templates
+    hasTenantId: mode !== "none",
+    // strict, optional, scoped all have TenantId
+    isNullableTenant: mode === "optional" || mode === "scoped",
+    // Guid? vs Guid
+    hasScope: mode === "scoped",
+    // only scoped has EntityScope
+    tenantMode: mode
+  };
+}
+var ProjectConfigSchema, SmartStackConfigSchema, ConventionsConfigSchema, EfCoreContextSchema, EfCoreConfigSchema, ScaffoldingConfigSchema, ConfigSchema, TenantModeSchema, ValidateConventionsInputSchema, CheckMigrationsInputSchema, EntityPropertySchema, ScaffoldExtensionInputSchema, ApiDocsInputSchema, SuggestMigrationInputSchema, GeneratePermissionsInputSchema, TestTypeSchema, TestTargetSchema, ScaffoldTestsInputSchema, AnalyzeTestCoverageInputSchema, ValidateTestConventionsInputSchema, SuggestTestScenariosInputSchema, SecurityCheckSchema, ValidateSecurityInputSchema, QualityMetricSchema, AnalyzeCodeQualityInputSchema, ScaffoldApiClientInputSchema, ScaffoldRoutesInputSchema, ValidateFrontendRoutesInputSchema, SlotDefinitionSchema, ScaffoldFrontendExtensionInputSchema, AnalyzeExtensionPointsInputSchema, AnalyzeHierarchyPatternsInputSchema, ReviewCodeCheckSchema, ReviewCodeInputSchema;
 var init_types3 = __esm({
   "src/mcp/types/index.ts"() {
     "use strict";
@@ -25854,6 +25878,7 @@ var init_types3 = __esm({
       // Resolved DbContext to use (from projectConfig or default)
       defaultDbContext: external_exports.enum(["core", "extensions"]).default("core")
     });
+    TenantModeSchema = external_exports.enum(["strict", "optional", "scoped", "none"]).default("strict");
     ValidateConventionsInputSchema = external_exports.object({
       path: external_exports.string().optional().describe("Project path to validate (default: SmartStack.app path)"),
       checks: external_exports.array(external_exports.enum(["tables", "migrations", "services", "namespaces", "entities", "tenants", "controllers", "layouts", "tabs", "hierarchies", "protected-actions", "permissions", "frontend-routes", "feature-json", "all"])).default(["all"]).describe("Types of checks to perform")
@@ -25877,7 +25902,8 @@ var init_types3 = __esm({
         baseEntity: external_exports.string().optional().describe("Base entity to extend (for entity type)"),
         methods: external_exports.array(external_exports.string()).optional().describe("Methods to generate (for service type)"),
         outputPath: external_exports.string().optional().describe("Custom output path"),
-        isSystemEntity: external_exports.boolean().optional().describe("If true, creates a system entity without TenantId"),
+        isSystemEntity: external_exports.boolean().optional().describe("[DEPRECATED: use tenantMode] If true, creates a system entity without TenantId"),
+        tenantMode: TenantModeSchema.optional().describe("Tenant isolation mode: strict (default), optional (cross-tenant), scoped (with EntityScope), none (no tenant)"),
         tablePrefix: external_exports.string().optional().describe('Domain prefix for table name (e.g., "auth_", "nav_", "cfg_")'),
         schema: external_exports.enum(["core", "extensions"]).optional().describe("Database schema (default: core)"),
         dryRun: external_exports.boolean().optional().describe("If true, preview generated code without writing files"),
@@ -25928,7 +25954,8 @@ var init_types3 = __esm({
         includeAuthorization: external_exports.boolean().default(false).describe("Include authorization tests"),
         includePerformance: external_exports.boolean().default(false).describe("Include performance tests"),
         entityProperties: external_exports.array(EntityPropertySchema).optional().describe("Entity properties for test generation"),
-        isSystemEntity: external_exports.boolean().default(false).describe("If true, entity has no TenantId"),
+        isSystemEntity: external_exports.boolean().default(false).describe("[DEPRECATED: use tenantMode] If true, entity has no TenantId"),
+        tenantMode: TenantModeSchema.optional().describe("Tenant isolation mode: strict (default), optional (cross-tenant), scoped (with EntityScope), none (no tenant)"),
         dryRun: external_exports.boolean().default(false).describe("Preview without writing files")
       }).optional()
     });
@@ -26668,7 +26695,7 @@ import path8 from "path";
 async function handleValidateConventions(args, config2) {
   const input = ValidateConventionsInputSchema.parse(args);
   const projectPath = input.path || config2.smartstack.projectPath;
-  const checks = input.checks.includes("all") ? ["tables", "migrations", "services", "namespaces", "entities", "tenants", "controllers", "layouts", "tabs", "hierarchies", "protected-actions", "permissions", "frontend-routes", "feature-json"] : input.checks;
+  const checks = input.checks.includes("all") ? ["tables", "migrations", "services", "namespaces", "entities", "tenants", "controllers", "layouts", "tabs", "hierarchies", "protected-actions", "permissions", "frontend-routes", "feature-json", "code-patterns"] : input.checks;
   logger.info("Validating conventions", { projectPath, checks });
   const result = {
     valid: true,
@@ -26719,6 +26746,9 @@ async function handleValidateConventions(args, config2) {
   if (checks.includes("feature-json")) {
     await validateFeatureJson(structure, config2, result);
   }
+  if (checks.includes("code-patterns")) {
+    await validateCodePatterns(structure, config2, result);
+  }
   result.valid = result.errors.length === 0;
   result.summary = generateSummary(result, checks);
   return formatResult(result);
@@ -26901,8 +26931,6 @@ async function validateNamespaces(structure, config2, result) {
       if (namespaceMatch) {
         const namespace = namespaceMatch[1];
         if (!namespace.startsWith(layer.expected)) {
-          const lastDot = namespace.lastIndexOf(".");
-          const namespaceSuffix = lastDot > 0 ? namespace.substring(lastDot + 1) : "";
           const isValidLayerPattern = ["Domain", "Application", "Infrastructure", "Api"].some((l) => namespace.includes(`.${l}`) || namespace.endsWith(`.${l}`));
           const severity = isValidLayerPattern ? "warning" : "error";
           result.errors.push({
@@ -26940,16 +26968,19 @@ async function validateEntities(structure, _config, result) {
     const hasBaseEntity = inheritance.includes("BaseEntity");
     const hasSystemEntity = inheritance.includes("SystemEntity");
     const hasITenantEntity = inheritance.includes("ITenantEntity");
+    const hasIOptionalTenantEntity = inheritance.includes("IOptionalTenantEntity");
+    const hasIScopedTenantEntity = inheritance.includes("IScopedTenantEntity");
+    const hasAnyTenantInterface = hasITenantEntity || hasIOptionalTenantEntity || hasIScopedTenantEntity;
     if (!hasBaseEntity && !hasSystemEntity) {
       continue;
     }
-    if (hasBaseEntity && !hasSystemEntity && !hasITenantEntity) {
+    if (hasBaseEntity && !hasSystemEntity && !hasAnyTenantInterface) {
       result.warnings.push({
         type: "warning",
         category: "entities",
-        message: `Entity "${entityName}" inherits BaseEntity but doesn't implement ITenantEntity`,
+        message: `Entity "${entityName}" inherits BaseEntity but doesn't implement any tenant interface`,
         file: path8.relative(structure.root, file),
-        suggestion: "Add ITenantEntity interface for multi-tenant support, or use SystemEntity for platform-level entities"
+        suggestion: "Add ITenantEntity (strict), IOptionalTenantEntity (cross-tenant), or IScopedTenantEntity (with scope) for multi-tenant support"
       });
     }
     if (!content.includes(`private ${entityName}()`)) {
@@ -26982,7 +27013,9 @@ async function validateTenantAwareness(structure, _config, result) {
     return;
   }
   const entityFiles = await findFiles("**/*.cs", { cwd: structure.domain });
-  let tenantAwareCount = 0;
+  let strictCount = 0;
+  let optionalCount = 0;
+  let scopedCount = 0;
   let systemEntityCount = 0;
   let ambiguousCount = 0;
   for (const file of entityFiles) {
@@ -26991,15 +27024,19 @@ async function validateTenantAwareness(structure, _config, result) {
     if (!classMatch) continue;
     const entityName = classMatch[1];
     const inheritance = classMatch[2]?.trim() || "";
-    if (!inheritance.includes("Entity") && !inheritance.includes("ITenant")) {
+    if (!inheritance.includes("Entity") && !inheritance.includes("ITenant") && !inheritance.includes("IOptional") && !inheritance.includes("IScoped")) {
       continue;
     }
-    const hasITenantEntity = inheritance.includes("ITenantEntity");
+    const hasIScopedTenantEntity = inheritance.includes("IScopedTenantEntity");
+    const hasIOptionalTenantEntity = inheritance.includes("IOptionalTenantEntity") && !hasIScopedTenantEntity;
+    const hasITenantEntity = inheritance.includes("ITenantEntity") && !hasIOptionalTenantEntity && !hasIScopedTenantEntity;
     const hasSystemEntity = inheritance.includes("SystemEntity");
+    const hasAnyTenantInterface = hasITenantEntity || hasIOptionalTenantEntity || hasIScopedTenantEntity;
     const hasTenantId = content.includes("TenantId");
     const hasTenantIdProperty = content.includes("public Guid TenantId") || content.includes("public required Guid TenantId");
+    const hasNullableTenantIdProperty = content.includes("public Guid? TenantId");
     if (hasITenantEntity) {
-      tenantAwareCount++;
+      strictCount++;
       if (!hasTenantIdProperty) {
         result.errors.push({
           type: "error",
@@ -27020,6 +27057,39 @@ async function validateTenantAwareness(structure, _config, result) {
         });
       }
     }
+    if (hasIOptionalTenantEntity) {
+      optionalCount++;
+      if (!hasNullableTenantIdProperty) {
+        result.errors.push({
+          type: "error",
+          category: "tenants",
+          message: `Entity "${entityName}" implements IOptionalTenantEntity but TenantId is not Guid?`,
+          file: path8.relative(structure.root, file),
+          suggestion: "TenantId must be nullable for IOptionalTenantEntity: public Guid? TenantId { get; private set; }"
+        });
+      }
+    }
+    if (hasIScopedTenantEntity) {
+      scopedCount++;
+      if (!hasNullableTenantIdProperty) {
+        result.errors.push({
+          type: "error",
+          category: "tenants",
+          message: `Entity "${entityName}" implements IScopedTenantEntity but TenantId is not Guid?`,
+          file: path8.relative(structure.root, file),
+          suggestion: "TenantId must be nullable for IScopedTenantEntity: public Guid? TenantId { get; private set; }"
+        });
+      }
+      if (!content.includes("EntityScope") && !content.includes("Scope")) {
+        result.errors.push({
+          type: "error",
+          category: "tenants",
+          message: `Entity "${entityName}" implements IScopedTenantEntity but is missing Scope property`,
+          file: path8.relative(structure.root, file),
+          suggestion: "Add: public EntityScope Scope { get; private set; }"
+        });
+      }
+    }
     if (hasSystemEntity) {
       systemEntityCount++;
       if (hasTenantId) {
@@ -27032,22 +27102,23 @@ async function validateTenantAwareness(structure, _config, result) {
         });
       }
     }
-    if (!hasITenantEntity && !hasSystemEntity && hasTenantId) {
+    if (!hasAnyTenantInterface && !hasSystemEntity && hasTenantId) {
       ambiguousCount++;
       result.warnings.push({
         type: "warning",
         category: "tenants",
-        message: `Entity "${entityName}" has TenantId but doesn't implement ITenantEntity`,
+        message: `Entity "${entityName}" has TenantId but doesn't implement any tenant interface`,
         file: path8.relative(structure.root, file),
-        suggestion: "Add ITenantEntity interface for explicit tenant-awareness"
+        suggestion: "Add ITenantEntity (strict), IOptionalTenantEntity (cross-tenant), or IScopedTenantEntity (scoped)"
       });
     }
   }
-  if (tenantAwareCount + systemEntityCount > 0) {
+  const totalTenant = strictCount + optionalCount + scopedCount;
+  if (totalTenant + systemEntityCount > 0) {
     result.warnings.push({
       type: "warning",
       category: "tenants",
-      message: `Tenant summary: ${tenantAwareCount} tenant-aware, ${systemEntityCount} system, ${ambiguousCount} ambiguous`
+      message: `Tenant summary: ${strictCount} strict, ${optionalCount} optional, ${scopedCount} scoped, ${systemEntityCount} system, ${ambiguousCount} ambiguous`
     });
   }
 }
@@ -27437,7 +27508,7 @@ async function validateHierarchies(structure, _config, result) {
     const hasSystemEntity = inheritance.includes("SystemEntity");
     if (!hasBaseEntity && !hasSystemEntity) continue;
     entityNames.add(entityName);
-    const hasITenantEntity = inheritance.includes("ITenantEntity");
+    const hasITenantEntity = inheritance.includes("ITenantEntity") || inheritance.includes("IOptionalTenantEntity") || inheritance.includes("IScopedTenantEntity");
     const selfRefMatch = content.match(
       new RegExp(
         `public\\s+(?:Guid\\??|${entityName}\\??)\\s+(Parent(?:Id)?|Parent${entityName}(?:Id)?)\\s*\\{`,
@@ -27520,7 +27591,7 @@ async function validateHierarchies(structure, _config, result) {
           category: "hierarchies",
           message: `Entity "${h.name}" has tenant-aware parent "${h.parentEntity}" but is not tenant-aware itself`,
           file: h.file,
-          suggestion: `Add ITenantEntity interface to ${h.name} for consistent tenant isolation.`
+          suggestion: `Add a tenant interface (ITenantEntity, IOptionalTenantEntity, or IScopedTenantEntity) to ${h.name} for consistent tenant isolation.`
         });
       }
     }
@@ -27991,6 +28062,60 @@ async function validateFeatureJson(structure, _config, result) {
     message: `Feature.json summary: ${featureFiles.length} file(s) validated`
   });
 }
+async function validateCodePatterns(structure, _config, result) {
+  const projectPath = structure.root || "";
+  if (!projectPath) return;
+  const validatorFiles = await findFiles("**/*Validator.cs", { cwd: path8.join(projectPath, "src") });
+  for (const file of validatorFiles) {
+    const fullPath = path8.join(projectPath, "src", file);
+    try {
+      const content = await readText(fullPath);
+      if (content.includes("^[a-z0-9_]+$") && !content.includes("^[a-z0-9_-]+$")) {
+        result.errors.push({
+          type: "error",
+          category: "code-patterns",
+          message: `Validator uses old Code regex without hyphen support`,
+          file,
+          suggestion: "Update regex to ^[a-z0-9_-]+$ to support auto-generated codes with hyphens (e.g., acme-emp-00001)"
+        });
+      }
+    } catch {
+    }
+  }
+  const serviceFiles = (await findFiles("**/*Service.cs", { cwd: path8.join(projectPath, "src") })).filter((f) => !path8.basename(f).startsWith("I"));
+  for (const file of serviceFiles) {
+    const fullPath = path8.join(projectPath, "src", file);
+    try {
+      const content = await readText(fullPath);
+      if (content.includes("ICodeGenerator")) {
+        const entityName = path8.basename(file).replace("Service.cs", "");
+        const dtoFiles = await findFiles(`**/Create${entityName}Dto.cs`, { cwd: path8.join(projectPath, "src") });
+        for (const dtoFile of dtoFiles) {
+          const dtoFullPath = path8.join(projectPath, "src", dtoFile);
+          try {
+            const dtoContent = await readText(dtoFullPath);
+            if (dtoContent.includes("public string Code")) {
+              result.warnings.push({
+                type: "warning",
+                category: "code-patterns",
+                message: `Create${entityName}Dto has Code property but service uses ICodeGenerator (code is auto-generated)`,
+                file: dtoFile,
+                suggestion: `Remove Code from Create${entityName}Dto \u2014 it is auto-generated by ICodeGenerator<${entityName}>`
+              });
+            }
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  result.warnings.push({
+    type: "warning",
+    category: "code-patterns",
+    message: `Code patterns check completed: ${validatorFiles.length} validators, ${serviceFiles.length} services scanned`
+  });
+}
 function generateSummary(result, checks) {
   const parts = [];
   parts.push(`Checks performed: ${checks.join(", ")}`);
@@ -28059,7 +28184,7 @@ var init_validate_conventions = __esm({
             type: "array",
             items: {
               type: "string",
-              enum: ["tables", "migrations", "services", "namespaces", "entities", "tenants", "controllers", "layouts", "tabs", "hierarchies", "protected-actions", "permissions", "frontend-routes", "feature-json", "all"]
+              enum: ["tables", "migrations", "services", "namespaces", "entities", "tenants", "controllers", "layouts", "tabs", "hierarchies", "protected-actions", "permissions", "frontend-routes", "feature-json", "code-patterns", "all"]
             },
             description: "Types of checks to perform",
             default: ["all"]
@@ -34474,6 +34599,8 @@ async function scaffoldFeature(name, options, structure, config2, result, dryRun
 }
 async function scaffoldService(name, options, structure, config2, result, dryRun = false) {
   const hierarchy = resolveHierarchy(options?.navRoute);
+  const tenantMode = resolveTenantMode(options);
+  const tmFlags = tenantModeToTemplateFlags(tenantMode);
   const interfaceNamespace = options?.namespace || `${config2.conventions.namespaces.application}.Common.Interfaces`;
   const implNamespace = hierarchy.infraPath ? `${config2.conventions.namespaces.infrastructure}.Services.${hierarchy.infraPath.replace(/[\\/]/g, ".")}` : `${config2.conventions.namespaces.infrastructure}.Services`;
   const methods = options?.methods || ["GetByIdAsync", "GetAllAsync", "CreateAsync", "UpdateAsync", "DeleteAsync"];
@@ -34504,32 +34631,46 @@ using System.Linq;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using SmartStack.Application.Common.Interfaces.Identity;
+{{#unless isNone}}
 using SmartStack.Application.Common.Interfaces.Tenants;
+{{/unless}}
 using SmartStack.Application.Common.Interfaces.Persistence;
 
 namespace {{implNamespace}};
 
 /// <summary>
 /// Service implementation for {{name}} operations.
+{{#if isStrict}}
 /// IMPORTANT: All queries MUST filter by tenant ID for multi-tenant isolation.
+{{else if isOptional}}
+/// Cross-tenant entity: EF global query filter includes shared (TenantId=null) + current tenant data.
+{{else if isScoped}}
+/// Scoped entity: EF global query filter includes shared + current tenant data. Scope controls visibility.
+{{/if}}
 /// IMPORTANT: GetAllAsync MUST support search parameter for frontend EntityLookup component.
 /// </summary>
 public class {{name}}Service : I{{name}}Service
 {
     private readonly IExtensionsDbContext _db;
     private readonly ICurrentUserService _currentUser;
+{{#unless isNone}}
     private readonly ICurrentTenantService _currentTenant;
+{{/unless}}
     private readonly ILogger<{{name}}Service> _logger;
 
     public {{name}}Service(
         IExtensionsDbContext db,
         ICurrentUserService currentUser,
+{{#unless isNone}}
         ICurrentTenantService currentTenant,
+{{/unless}}
         ILogger<{{name}}Service> logger)
     {
         _db = db;
         _currentUser = currentUser;
+{{#unless isNone}}
         _currentTenant = currentTenant;
+{{/unless}}
         _logger = logger;
     }
 
@@ -34537,14 +34678,28 @@ public class {{name}}Service : I{{name}}Service
     /// <inheritdoc />
     public async Task<object> {{this}}(CancellationToken cancellationToken = default)
     {
+{{#if ../isStrict}}
         var tenantId = _currentTenant.TenantId
-            ?? throw new UnauthorizedAccessException("Tenant context is required");
+            ?? throw new TenantContextRequiredException();
         _logger.LogInformation("Executing {{this}} for tenant {TenantId}", tenantId);
         // TODO: Implement {{this}} \u2014 ALL queries must filter by tenantId
+{{else if ../isOptional}}
+        // Cross-tenant: tenantId is nullable. null = shared data, Guid = tenant-specific.
+        // EF global filter automatically includes shared + current tenant data in queries.
+        var tenantId = _currentTenant.TenantId; // nullable \u2014 null means creating shared data
+        _logger.LogInformation("Executing {{this}} (tenantId: {TenantId})", tenantId?.ToString() ?? "shared");
+        // TODO: Implement {{this}}
+{{else if ../isScoped}}
+        // Scoped: tenantId is nullable. Scope controls visibility (Tenant/Shared/Platform).
+        var tenantId = _currentTenant.TenantId;
+        _logger.LogInformation("Executing {{this}} (tenantId: {TenantId})", tenantId?.ToString() ?? "shared");
+        // TODO: Implement {{this}}
+{{else}}
+        _logger.LogInformation("Executing {{this}}");
+        // TODO: Implement {{this}}
+{{/if}}
         // IMPORTANT: GetAllAsync MUST accept (string? search, int page, int pageSize) parameters
-        // to enable EntityLookup search on the frontend. Example:
-        //   if (!string.IsNullOrWhiteSpace(search))
-        //       query = query.Where(x => x.Name.Contains(search) || x.Code.Contains(search));
+        // to enable EntityLookup search on the frontend.
         await Task.CompletedTask;
         throw new NotImplementedException();
     }
@@ -34555,7 +34710,7 @@ public class {{name}}Service : I{{name}}Service
   const diTemplate = `// Add to DependencyInjection.cs or ServiceCollectionExtensions.cs:
 services.AddScoped<I{{name}}Service, {{name}}Service>();
 `;
-  const context = { interfaceNamespace, implNamespace, name, methods };
+  const context = { interfaceNamespace, implNamespace, name, methods, ...tmFlags };
   const interfaceContent = import_handlebars.default.compile(interfaceTemplate)(context);
   const implementationContent = import_handlebars.default.compile(implementationTemplate)(context);
   const diContent = import_handlebars.default.compile(diTemplate)(context);
@@ -34583,7 +34738,9 @@ async function scaffoldEntity(name, options, structure, config2, result, dryRun
   const hierarchy = resolveHierarchy(options?.navRoute);
   const namespace = options?.namespace || (hierarchy.domainPath ? `${config2.conventions.namespaces.domain}.${hierarchy.domainPath.replace(/[\\/]/g, ".")}` : config2.conventions.namespaces.domain);
   const baseEntity = options?.baseEntity;
-  const isSystemEntity = options?.isSystemEntity || false;
+  const tenantMode = resolveTenantMode(options);
+  const tmFlags = tenantModeToTemplateFlags(tenantMode);
+  const isSystemEntity = tmFlags.isSystemEntity;
   const tablePrefix = options?.tablePrefix || "ref_";
   const schema = options?.schema || config2.conventions.schemas.platform;
   const entityTemplate = `using System;
@@ -34593,23 +34750,49 @@ namespace {{namespace}};
 
 /// <summary>
 /// {{name}} entity{{#if baseEntity}} extending {{baseEntity}}{{/if}}
-{{#unless isSystemEntity}}
-/// Tenant-scoped: data is isolated per tenant
+{{#if isStrict}}
+/// Tenant-scoped: data is isolated per tenant (ITenantEntity)
+{{else if isOptional}}
+/// Cross-tenant: data can be shared across tenants or tenant-specific (IOptionalTenantEntity)
+{{else if isScoped}}
+/// Scoped: data visibility controlled by EntityScope (IScopedTenantEntity)
 {{else}}
 /// Platform-level entity: no tenant isolation
-{{/unless}}
+{{/if}}
 /// </summary>
-public class {{name}} : BaseEntity{{#unless isSystemEntity}}, ITenantEntity, IAuditableEntity{{else}}, IAuditableEntity{{/unless}}
+{{#if isStrict}}
+public class {{name}} : BaseEntity, ITenantEntity, IAuditableEntity
+{{else if isOptional}}
+public class {{name}} : BaseEntity, IOptionalTenantEntity, IAuditableEntity
+{{else if isScoped}}
+public class {{name}} : BaseEntity, IScopedTenantEntity, IAuditableEntity
+{{else}}
+public class {{name}} : BaseEntity, IAuditableEntity
+{{/if}}
 {
-{{#unless isSystemEntity}}
+{{#if hasTenantId}}
     // === MULTI-TENANT ===
 
+{{#if isNullableTenant}}
+    /// <summary>
+    /// Tenant identifier \u2014 null means shared across all tenants
+    /// </summary>
+    public Guid? TenantId { get; private set; }
+{{else}}
     /// <summary>
     /// Tenant identifier for multi-tenant isolation (required)
     /// </summary>
     public Guid TenantId { get; private set; }
+{{/if}}
 
-{{/unless}}
+{{/if}}
+{{#if hasScope}}
+    /// <summary>
+    /// Visibility scope: Tenant (tenant-specific), Shared (all tenants), Platform (admin only)
+    /// </summary>
+    public EntityScope Scope { get; private set; }
+
+{{/if}}
     // === AUDIT ===
 
     /// <summary>User who created this entity</summary>
@@ -34643,7 +34826,7 @@ public class {{name}} : BaseEntity{{#unless isSystemEntity}}, ITenantEntity, IAu
     /// <summary>
     /// Factory method to create a new {{name}}
     /// </summary>
-{{#unless isSystemEntity}}
+{{#if isStrict}}
     /// <param name="tenantId">Required tenant identifier</param>
     public static {{name}} Create(
         Guid tenantId)
@@ -34658,6 +34841,37 @@ public class {{name}} : BaseEntity{{#unless isSystemEntity}}, ITenantEntity, IAu
             CreatedAt = DateTime.UtcNow
         };
     }
+{{else if isOptional}}
+    /// <param name="tenantId">Tenant identifier \u2014 null for shared (cross-tenant) data</param>
+    public static {{name}} Create(
+        Guid? tenantId = null)
+    {
+        return new {{name}}
+        {
+            Id = Guid.NewGuid(),
+            TenantId = tenantId,
+            CreatedAt = DateTime.UtcNow
+        };
+    }
+{{else if isScoped}}
+    /// <param name="tenantId">Tenant identifier \u2014 null for shared/platform data</param>
+    /// <param name="scope">Visibility scope (default: Tenant)</param>
+    public static {{name}} Create(
+        Guid? tenantId = null,
+        EntityScope scope = EntityScope.Tenant)
+    {
+        // Validate scope-tenantId consistency
+        if (scope == EntityScope.Tenant && tenantId == null)
+            throw new ArgumentException("TenantId is required when scope is Tenant", nameof(tenantId));
+
+        return new {{name}}
+        {
+            Id = Guid.NewGuid(),
+            TenantId = tenantId,
+            Scope = scope,
+            CreatedAt = DateTime.UtcNow
+        };
+    }
 {{else}}
     public static {{name}} Create()
     {
@@ -34667,7 +34881,7 @@ public class {{name}} : BaseEntity{{#unless isSystemEntity}}, ITenantEntity, IAu
             CreatedAt = DateTime.UtcNow
         };
     }
-{{/unless}}
+{{/if}}
 
     /// <summary>
     /// Update the entity
@@ -34695,13 +34909,32 @@ public class {{name}}Configuration : IEntityTypeConfiguration<{{name}}>
 
         builder.HasKey(e => e.Id);
 
-{{#unless isSystemEntity}}
-        // Multi-tenant
+{{#if isStrict}}
+        // Multi-tenant (strict: TenantId required)
         builder.Property(e => e.TenantId).IsRequired();
         builder.HasIndex(e => e.TenantId)
             .HasDatabaseName("IX_{{tablePrefix}}{{name}}s_TenantId");
 
-{{/unless}}
+{{else if isOptional}}
+        // Multi-tenant (optional: TenantId nullable \u2014 null = shared across tenants)
+        builder.Property(e => e.TenantId).IsRequired(false);
+        builder.HasIndex(e => e.TenantId)
+            .HasDatabaseName("IX_{{tablePrefix}}{{name}}s_TenantId");
+
+{{else if isScoped}}
+        // Multi-tenant (scoped: TenantId nullable + EntityScope)
+        builder.Property(e => e.TenantId).IsRequired(false);
+        builder.HasIndex(e => e.TenantId)
+            .HasDatabaseName("IX_{{tablePrefix}}{{name}}s_TenantId");
+
+        builder.Property(e => e.Scope)
+            .IsRequired()
+            .HasConversion<string>()
+            .HasMaxLength(20);
+        builder.HasIndex(e => new { e.TenantId, e.Scope })
+            .HasDatabaseName("IX_{{tablePrefix}}{{name}}s_TenantId_Scope");
+
+{{/if}}
         // Audit fields (from IAuditableEntity)
         builder.Property(e => e.CreatedBy).HasMaxLength(256);
         builder.Property(e => e.UpdatedBy).HasMaxLength(256);
@@ -34725,7 +34958,7 @@ public class {{name}}Configuration : IEntityTypeConfiguration<{{name}}>
     namespace,
     name,
     baseEntity,
-    isSystemEntity,
+    ...tmFlags,
     tablePrefix,
     schema,
     infrastructureNamespace: config2.conventions.namespaces.infrastructure,
@@ -34765,7 +34998,9 @@ public class {{name}}Configuration : IEntityTypeConfiguration<{{name}}>
   result.instructions.push("");
   result.instructions.push("BaseEntity fields (inherited):");
   result.instructions.push(`- Id (Guid), CreatedAt (DateTime), UpdatedAt (DateTime?)`);
-  result.instructions.push(`${isSystemEntity ? "" : "- TenantId (Guid) \u2014 from ITenantEntity"}`);
+  if (tenantMode === "strict") result.instructions.push("- TenantId (Guid) \u2014 from ITenantEntity");
+  else if (tenantMode === "optional") result.instructions.push("- TenantId (Guid?) \u2014 from IOptionalTenantEntity (null = shared)");
+  else if (tenantMode === "scoped") result.instructions.push("- TenantId (Guid?) + Scope (EntityScope) \u2014 from IScopedTenantEntity");
   result.instructions.push("- CreatedBy, UpdatedBy (string?) \u2014 from IAuditableEntity");
   result.instructions.push("- Add your own business properties (Code, Name, etc.) as needed");
   if (options?.withSeedData) {
@@ -34794,7 +35029,8 @@ async function scaffoldSeedData(name, options, structure, config2, result, dryRu
     "loc_": "Localization"
   };
   const domain = options?.seedDataDomain || domainMap[tablePrefix] || "Reference";
-  const isSystemEntity = options?.isSystemEntity || false;
+  const tenantMode = resolveTenantMode(options);
+  const tmFlags = tenantModeToTemplateFlags(tenantMode);
   const seedDataTemplate = `using SmartStack.Domain.{{domainNamespace}};
 
 namespace SmartStack.Infrastructure.Persistence.Seeding.Data.{{domain}};
@@ -34836,9 +35072,14 @@ public static class {{name}}SeedData
             new
             {
                 Id = ExampleId,
-{{#unless isSystemEntity}}
-                TenantId = (Guid?)null, // Seed data systeme sans tenant
-{{/unless}}
+{{#if isStrict}}
+                TenantId = SeedConstants.DefaultTenantId, // Seed data tenant-specific
+{{else if isOptional}}
+                TenantId = (Guid?)null, // Shared cross-tenant seed data
+{{else if isScoped}}
+                TenantId = (Guid?)null, // Shared seed data
+                Scope = EntityScope.Shared,
+{{/if}}
                 // TODO: Ajouter les proprietes specifiques
                 CreatedAt = seedDate
             }
@@ -34855,7 +35096,7 @@ public static class {{name}}SeedData
     name,
     domain,
     domainNamespace: domain,
-    isSystemEntity,
+    ...tmFlags,
     exampleGuid
   };
   const seedDataContent = import_handlebars.default.compile(seedDataTemplate)(context);
@@ -35380,7 +35621,9 @@ export function use{{name}}(options: Use{{name}}Options = {}) {
   result.instructions.push("```");
 }
 async function scaffoldTest(name, options, structure, config2, result, dryRun = false) {
-  const isSystemEntity = options?.isSystemEntity || false;
+  const tenantMode = resolveTenantMode(options);
+  const tmFlags = tenantModeToTemplateFlags(tenantMode);
+  const isSystemEntity = tmFlags.isSystemEntity;
   const serviceTestTemplate2 = `using System;
 using System.Threading;
 using System.Threading.Tasks;
@@ -35486,7 +35729,7 @@ public class {{name}}ServiceTests
 `;
   const context = {
     name,
-    isSystemEntity
+    ...tmFlags
   };
   const testContent = import_handlebars.default.compile(serviceTestTemplate2)(context);
   const testsPath = structure.application ? path10.join(path10.dirname(structure.application), `${path10.basename(structure.application)}.Tests`, "Services") : path10.join(config2.smartstack.projectPath, "Application.Tests", "Services");
@@ -35507,7 +35750,10 @@ public class {{name}}ServiceTests
 async function scaffoldDtos(name, options, structure, config2, result, dryRun = false) {
   const hierarchy = resolveHierarchy(options?.navRoute);
   const namespace = options?.namespace || (hierarchy.domainPath ? `${config2.conventions.namespaces.application}.${hierarchy.domainPath.replace(/[\\/]/g, ".")}.DTOs` : `${config2.conventions.namespaces.application}.DTOs`);
-  const isSystemEntity = options?.isSystemEntity || false;
+  const tenantMode = resolveTenantMode(options);
+  const tmFlags = tenantModeToTemplateFlags(tenantMode);
+  const codePattern = options?.codePattern;
+  const isAutoCode = codePattern && codePattern.strategy && codePattern.strategy !== "manual";
   const properties = options?.entityProperties || [
     { name: "Name", type: "string", required: true, maxLength: 200 },
     { name: "Description", type: "string?", required: false, maxLength: 500 }
@@ -35524,11 +35770,22 @@ public record {{name}}ResponseDto
     /// <summary>Unique identifier</summary>
     public Guid Id { get; init; }
 
-{{#unless isSystemEntity}}
+{{#if isStrict}}
     /// <summary>Tenant identifier</summary>
     public Guid TenantId { get; init; }
 
-{{/unless}}
+{{else if isOptional}}
+    /// <summary>Tenant identifier \u2014 null for shared (cross-tenant) data</summary>
+    public Guid? TenantId { get; init; }
+
+{{else if isScoped}}
+    /// <summary>Tenant identifier \u2014 null for shared/platform data</summary>
+    public Guid? TenantId { get; init; }
+
+    /// <summary>Visibility scope</summary>
+    public string Scope { get; init; } = "Tenant";
+
+{{/if}}
     /// <summary>Unique code</summary>
     public string Code { get; init; } = string.Empty;
 
@@ -35547,7 +35804,37 @@ public record {{name}}ResponseDto
     public string? CreatedBy { get; init; }
 }
 `;
-  const createDtoTemplate = `using System;
+  const createDtoTemplate = isAutoCode ? `using System;
+using System.ComponentModel.DataAnnotations;
+
+namespace {{namespace}};
+
+/// <summary>
+/// DTO for creating a new {{name}}.
+/// Code is auto-generated by ICodeGenerator&lt;{{name}}&gt; \u2014 not user-provided.
+/// </summary>
+public record Create{{name}}Dto
+{
+{{#each properties}}
+{{#if required}}
+    /// <summary>{{name}} (required)</summary>
+    [Required]
+{{#if maxLength}}
+    [MaxLength({{maxLength}})]
+{{/if}}
+    public {{type}} {{name}} { get; init; }{{#if (eq type "string")}} = string.Empty;{{/if}}
+
+{{else}}
+    /// <summary>{{name}} (optional)</summary>
+{{#if maxLength}}
+    [MaxLength({{maxLength}})]
+{{/if}}
+    public {{type}} {{name}} { get; init; }
+
+{{/if}}
+{{/each}}
+}
+` : `using System;
 using System.ComponentModel.DataAnnotations;
 
 namespace {{namespace}};
@@ -35616,7 +35903,7 @@ public record Update{{name}}Dto
   const context = {
     namespace,
     name,
-    isSystemEntity,
+    ...tmFlags,
     properties
   };
   const responseContent = import_handlebars.default.compile(responseDtoTemplate)(context);
@@ -35640,14 +35927,49 @@ public record Update{{name}}Dto
   result.instructions.push(`- ${name}ResponseDto: For API responses`);
   result.instructions.push(`- Create${name}Dto: For POST requests`);
   result.instructions.push(`- Update${name}Dto: For PUT requests`);
+  if (isAutoCode) {
+    const cp2 = codePattern;
+    const strategy = cp2.strategy || "sequential";
+    const prefix = cp2.prefix || name.toLowerCase().substring(0, 3);
+    const digits = cp2.digits || Math.max(4, Math.ceil(Math.log10((cp2.estimatedVolume || 1e3) * 10)));
+    const separator = cp2.separator || "-";
+    const includeTenant = cp2.includeTenantSlug !== false;
+    const example = includeTenant ? `{tenant}${separator}${prefix}${separator}${"0".repeat(digits - 1)}1` : `${prefix}${separator}${"0".repeat(digits - 1)}1`;
+    result.instructions.push("");
+    result.instructions.push(`## Code Auto-Generation (strategy: ${strategy})`);
+    result.instructions.push(`Code is auto-generated for ${name} \u2014 removed from Create${name}Dto.`);
+    result.instructions.push(`Example: ${example}`);
+    result.instructions.push("");
+    result.instructions.push("Required implementation (see references/code-generation.md):");
+    result.instructions.push(`1. Register ICodeGenerator<${name}> in DependencyInjection.cs:`);
+    result.instructions.push(`   services.AddScoped<ICodeGenerator<${name}>>(sp =>`);
+    result.instructions.push(`       new CodeGenerator<${name}>(`);
+    result.instructions.push(`           sp.GetRequiredService<IExtensionsDbContext>(),`);
+    result.instructions.push(`           sp.GetRequiredService<ICurrentTenantService>(),`);
+    result.instructions.push(`           new CodePatternConfig(CodeStrategy.${strategy.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("")}, "${prefix}", ${includeTenant}, "${separator}", ${cp2.estimatedVolume || 1e3}, ${digits}),`);
+    result.instructions.push(`           sp.GetRequiredService<ILogger<CodeGenerator<${name}>>>()));`);
+    result.instructions.push("");
+    result.instructions.push(`2. Inject ICodeGenerator<${name}> in ${name}Service constructor`);
+    result.instructions.push(`3. Call _codeGenerator.NextCodeAsync(ct) in CreateAsync BEFORE entity creation`);
+    result.instructions.push(`4. Code field is NOT in Create${name}Dto \u2014 auto-generated, not user-provided`);
+  }
 }
 async function scaffoldValidator(name, options, structure, config2, result, dryRun = false) {
   const hierarchy = resolveHierarchy(options?.navRoute);
   const namespace = options?.namespace || (hierarchy.domainPath ? `${config2.conventions.namespaces.application}.${hierarchy.domainPath.replace(/[\\/]/g, ".")}.Validators` : `${config2.conventions.namespaces.application}.Validators`);
+  const codePatternValidator = options?.codePattern;
+  const isAutoCodeValidator = codePatternValidator && codePatternValidator.strategy && codePatternValidator.strategy !== "manual";
   const properties = options?.entityProperties || [
     { name: "Name", type: "string", required: true, maxLength: 200 },
     { name: "Description", type: "string?", required: false, maxLength: 500 }
   ];
+  const codeValidationRules = isAutoCodeValidator ? `        // Code is auto-generated by ICodeGenerator<{{name}}> \u2014 no validation needed in CreateDto
+` : `        RuleFor(x => x.Code)
+            .NotEmpty().WithMessage("Code is required")
+            .MaximumLength(100).WithMessage("Code must not exceed 100 characters")
+            .Matches("^[a-z0-9_-]+$").WithMessage("Code must be lowercase alphanumeric with underscores and hyphens");
+
+`;
   const createValidatorTemplate = `using FluentValidation;
 using ${config2.conventions.namespaces.application}.DTOs;
 
@@ -35660,11 +35982,7 @@ public class Create{{name}}DtoValidator : AbstractValidator<Create{{name}}Dto>
 {
     public Create{{name}}DtoValidator()
     {
-        RuleFor(x => x.Code)
-            .NotEmpty().WithMessage("Code is required")
-            .MaximumLength(100).WithMessage("Code must not exceed 100 characters")
-            .Matches("^[a-z0-9_]+$").WithMessage("Code must be lowercase alphanumeric with underscores");
-
+${codeValidationRules}
 {{#each properties}}
 {{#if required}}
         RuleFor(x => x.{{name}})
@@ -35738,7 +36056,8 @@ public class Update{{name}}DtoValidator : AbstractValidator<Update{{name}}Dto>
 }
 async function scaffoldRepository(name, options, structure, config2, result, dryRun = false) {
   const hierarchy = resolveHierarchy(options?.navRoute);
-  const isSystemEntity = options?.isSystemEntity || false;
+  const tenantMode = resolveTenantMode(options);
+  const tmFlags = tenantModeToTemplateFlags(tenantMode);
   const schema = options?.schema || config2.conventions.schemas.platform;
   const dbContextName = schema === "extensions" ? "ExtensionsDbContext" : "CoreDbContext";
   const interfaceTemplate = `using System;
@@ -35757,14 +36076,43 @@ public interface I{{name}}Repository
     /// <summary>Get entity by ID</summary>
     Task<{{name}}?> GetByIdAsync(Guid id, CancellationToken ct = default);
 
+{{#if isStrict}}
+    /// <summary>Get entity by code (tenant-scoped)</summary>
+    Task<{{name}}?> GetByCodeAsync(Guid tenantId, string code, CancellationToken ct = default);
+
+    /// <summary>Get all entities for tenant</summary>
+    Task<IReadOnlyList<{{name}}>> GetAllAsync(Guid tenantId, CancellationToken ct = default);
+
+    /// <summary>Check if code exists in tenant</summary>
+    Task<bool> ExistsAsync(Guid tenantId, string code, CancellationToken ct = default);
+{{else if isOptional}}
+    /// <summary>Get entity by code (tenant-scoped or shared)</summary>
+    Task<{{name}}?> GetByCodeAsync(Guid? tenantId, string code, CancellationToken ct = default);
+
+    /// <summary>Get all entities (includes shared + current tenant via EF global filter)</summary>
+    Task<IReadOnlyList<{{name}}>> GetAllAsync(CancellationToken ct = default);
+
+    /// <summary>Check if code exists (tenant-scoped or shared)</summary>
+    Task<bool> ExistsAsync(Guid? tenantId, string code, CancellationToken ct = default);
+{{else if isScoped}}
+    /// <summary>Get entity by code (scoped)</summary>
+    Task<{{name}}?> GetByCodeAsync(Guid? tenantId, string code, CancellationToken ct = default);
+
+    /// <summary>Get all entities (includes shared + current tenant via EF global filter)</summary>
+    Task<IReadOnlyList<{{name}}>> GetAllAsync(CancellationToken ct = default);
+
+    /// <summary>Check if code exists (scoped)</summary>
+    Task<bool> ExistsAsync(Guid? tenantId, string code, CancellationToken ct = default);
+{{else}}
     /// <summary>Get entity by code</summary>
-    Task<{{name}}?> GetByCodeAsync({{#unless isSystemEntity}}Guid tenantId, {{/unless}}string code, CancellationToken ct = default);
+    Task<{{name}}?> GetByCodeAsync(string code, CancellationToken ct = default);
 
-    /// <summary>Get all entities{{#unless isSystemEntity}} for tenant{{/unless}}</summary>
-    Task<IReadOnlyList<{{name}}>> GetAllAsync({{#unless isSystemEntity}}Guid tenantId, {{/unless}}CancellationToken ct = default);
+    /// <summary>Get all entities</summary>
+    Task<IReadOnlyList<{{name}}>> GetAllAsync(CancellationToken ct = default);
 
-    /// <summary>Check if code exists{{#unless isSystemEntity}} in tenant{{/unless}}</summary>
-    Task<bool> ExistsAsync({{#unless isSystemEntity}}Guid tenantId, {{/unless}}string code, CancellationToken ct = default);
+    /// <summary>Check if code exists</summary>
+    Task<bool> ExistsAsync(string code, CancellationToken ct = default);
+{{/if}}
 
     /// <summary>Add new entity</summary>
     Task<{{name}}> AddAsync({{name}} entity, CancellationToken ct = default);
@@ -35806,29 +36154,108 @@ public class {{name}}Repository : I{{name}}Repository
             .FirstOrDefaultAsync(e => e.Id == id, ct);
     }
 
+{{#if isStrict}}
     /// <inheritdoc />
-    public async Task<{{name}}?> GetByCodeAsync({{#unless isSystemEntity}}Guid tenantId, {{/unless}}string code, CancellationToken ct = default)
+    public async Task<{{name}}?> GetByCodeAsync(Guid tenantId, string code, CancellationToken ct = default)
     {
         return await _context.{{name}}s
-            .FirstOrDefaultAsync(e => {{#unless isSystemEntity}}e.TenantId == tenantId && {{/unless}}e.Code == code.ToLowerInvariant(), ct);
+            .FirstOrDefaultAsync(e => e.TenantId == tenantId && e.Code == code.ToLowerInvariant(), ct);
     }
 
     /// <inheritdoc />
-    public async Task<IReadOnlyList<{{name}}>> GetAllAsync({{#unless isSystemEntity}}Guid tenantId, {{/unless}}CancellationToken ct = default)
+    public async Task<IReadOnlyList<{{name}}>> GetAllAsync(Guid tenantId, CancellationToken ct = default)
     {
         return await _context.{{name}}s
-            {{#unless isSystemEntity}}.Where(e => e.TenantId == tenantId){{/unless}}
+            .Where(e => e.TenantId == tenantId)
             .OrderBy(e => e.Code)
             .ToListAsync(ct);
     }
 
     /// <inheritdoc />
-    public async Task<bool> ExistsAsync({{#unless isSystemEntity}}Guid tenantId, {{/unless}}string code, CancellationToken ct = default)
+    public async Task<bool> ExistsAsync(Guid tenantId, string code, CancellationToken ct = default)
     {
         return await _context.{{name}}s
-            .AnyAsync(e => {{#unless isSystemEntity}}e.TenantId == tenantId && {{/unless}}e.Code == code.ToLowerInvariant(), ct);
+            .AnyAsync(e => e.TenantId == tenantId && e.Code == code.ToLowerInvariant(), ct);
+    }
+{{else if isOptional}}
+    /// <inheritdoc />
+    public async Task<{{name}}?> GetByCodeAsync(Guid? tenantId, string code, CancellationToken ct = default)
+    {
+        // For optional tenant: match exact tenantId (null = shared, Guid = tenant-specific)
+        return await _context.{{name}}s
+            .FirstOrDefaultAsync(e =>
+                (tenantId == null ? e.TenantId == null : e.TenantId == tenantId)
+                && e.Code == code.ToLowerInvariant(), ct);
     }
 
+    /// <inheritdoc />
+    public async Task<IReadOnlyList<{{name}}>> GetAllAsync(CancellationToken ct = default)
+    {
+        // EF global query filter automatically includes shared (null) + current tenant
+        return await _context.{{name}}s
+            .OrderBy(e => e.Code)
+            .ToListAsync(ct);
+    }
+
+    /// <inheritdoc />
+    public async Task<bool> ExistsAsync(Guid? tenantId, string code, CancellationToken ct = default)
+    {
+        return await _context.{{name}}s
+            .AnyAsync(e =>
+                (tenantId == null ? e.TenantId == null : e.TenantId == tenantId)
+                && e.Code == code.ToLowerInvariant(), ct);
+    }
+{{else if isScoped}}
+    /// <inheritdoc />
+    public async Task<{{name}}?> GetByCodeAsync(Guid? tenantId, string code, CancellationToken ct = default)
+    {
+        return await _context.{{name}}s
+            .FirstOrDefaultAsync(e =>
+                (tenantId == null ? e.TenantId == null : e.TenantId == tenantId)
+                && e.Code == code.ToLowerInvariant(), ct);
+    }
+
+    /// <inheritdoc />
+    public async Task<IReadOnlyList<{{name}}>> GetAllAsync(CancellationToken ct = default)
+    {
+        // EF global query filter automatically includes shared (null) + current tenant
+        return await _context.{{name}}s
+            .OrderBy(e => e.Code)
+            .ToListAsync(ct);
+    }
+
+    /// <inheritdoc />
+    public async Task<bool> ExistsAsync(Guid? tenantId, string code, CancellationToken ct = default)
+    {
+        return await _context.{{name}}s
+            .AnyAsync(e =>
+                (tenantId == null ? e.TenantId == null : e.TenantId == tenantId)
+                && e.Code == code.ToLowerInvariant(), ct);
+    }
+{{else}}
+    /// <inheritdoc />
+    public async Task<{{name}}?> GetByCodeAsync(string code, CancellationToken ct = default)
+    {
+        return await _context.{{name}}s
+            .FirstOrDefaultAsync(e => e.Code == code.ToLowerInvariant(), ct);
+    }
+
+    /// <inheritdoc />
+    public async Task<IReadOnlyList<{{name}}>> GetAllAsync(CancellationToken ct = default)
+    {
+        return await _context.{{name}}s
+            .OrderBy(e => e.Code)
+            .ToListAsync(ct);
+    }
+
+    /// <inheritdoc />
+    public async Task<bool> ExistsAsync(string code, CancellationToken ct = default)
+    {
+        return await _context.{{name}}s
+            .AnyAsync(e => e.Code == code.ToLowerInvariant(), ct);
+    }
+{{/if}}
+
     /// <inheritdoc />
     public async Task<{{name}}> AddAsync({{name}} entity, CancellationToken ct = default)
     {
@@ -35854,7 +36281,7 @@ public class {{name}}Repository : I{{name}}Repository
 `;
   const context = {
     name,
-    isSystemEntity,
+    ...tmFlags,
     dbContextName
   };
   const interfaceContent = import_handlebars.default.compile(interfaceTemplate)(context);
@@ -35981,7 +36408,12 @@ var init_scaffold_extension = __esm({
               },
               isSystemEntity: {
                 type: "boolean",
-                description: "If true, creates a system entity without TenantId (for entity type)"
+                description: "[DEPRECATED: use tenantMode] If true, creates a system entity without TenantId"
+              },
+              tenantMode: {
+                type: "string",
+                enum: ["strict", "optional", "scoped", "none"],
+                description: "Tenant isolation mode: strict (ITenantEntity, default), optional (IOptionalTenantEntity, cross-tenant), scoped (IScopedTenantEntity with EntityScope), none (no tenant)"
               },
               tablePrefix: {
                 type: "string",
@@ -36061,6 +36493,22 @@ var init_scaffold_extension = __esm({
                 type: "string",
                 enum: ["ancestors", "descendants", "both"],
                 description: "Direction for hierarchy traversal function (default: both)"
+              },
+              codePattern: {
+                type: "object",
+                description: 'Code auto-generation pattern for this entity. When strategy != "manual", Code is auto-generated and removed from CreateDto.',
+                properties: {
+                  strategy: {
+                    type: "string",
+                    enum: ["sequential", "timestamp-daily", "timestamp-minute", "year-sequential", "uuid-short", "manual"],
+                    description: "Code generation strategy"
+                  },
+                  prefix: { type: "string", description: "Entity prefix (2-6 lowercase letters, e.g., emp, inv)" },
+                  includeTenantSlug: { type: "boolean", description: "Include tenant slug in code (default: true)" },
+                  separator: { type: "string", enum: ["-", "_"], description: "Segment separator (default: -)" },
+                  estimatedVolume: { type: "number", description: "Estimated records per tenant (used for digit calculation via x10 rule)" },
+                  digits: { type: "number", description: "Digit count for sequential part (default: auto-calculated from volume)" }
+                }
               }
             }
           }
@@ -52883,6 +53331,8 @@ async function handleScaffoldTests(args, config2) {
     files: [],
     instructions: []
   };
+  const tenantMode = resolveTenantMode(input.options);
+  const tmFlags = tenantModeToTemplateFlags(tenantMode);
   const options = {
     includeEdgeCases: input.options?.includeEdgeCases ?? true,
     includeTenantIsolation: input.options?.includeTenantIsolation ?? true,
@@ -52890,7 +53340,8 @@ async function handleScaffoldTests(args, config2) {
     includeAudit: input.options?.includeAudit ?? true,
     includeValidation: input.options?.includeValidation ?? true,
     includeAuthorization: input.options?.includeAuthorization ?? false,
-    isSystemEntity: input.options?.isSystemEntity ?? false
+    isSystemEntity: tmFlags.isSystemEntity,
+    ...tmFlags
   };
   const testTypes = input.testTypes || ["unit"];
   try {
@@ -53249,7 +53700,12 @@ var init_scaffold_tests = __esm({
               isSystemEntity: {
                 type: "boolean",
                 default: false,
-                description: "If true, entity has no TenantId"
+                description: "[DEPRECATED: use tenantMode] If true, entity has no TenantId"
+              },
+              tenantMode: {
+                type: "string",
+                enum: ["strict", "optional", "scoped", "none"],
+                description: "Tenant isolation mode: strict (default), optional (cross-tenant), scoped (with EntityScope), none (no tenant)"
               },
               dryRun: {
                 type: "boolean",
@@ -56595,9 +57051,8 @@ import type {
   ${name},
   ${name}CreateRequest,
   ${name}UpdateRequest,
-  ${name}ListResponse,
-  PaginatedRequest,
-  PaginatedResponse
+  PaginationParams,
+  PaginatedResult
 } from '../types/${nameLower}';
 
 const ROUTE = getRoute('${navRoute}');
@@ -56606,8 +57061,8 @@ export const ${nameLower}Api = {
 ${methods.includes("getAll") ? `  /**
    * Get all ${name}s with pagination
    */
-  async getAll(params?: PaginatedRequest): Promise<PaginatedResponse<${name}>> {
-    const response = await apiClient.get<${name}ListResponse>(ROUTE.api, { params });
+  async getAll(params?: PaginationParams): Promise<PaginatedResult<${name}>> {
+    const response = await apiClient.get<PaginatedResult<${name}>>(ROUTE.api, { params });
     return response.data;
   },
 ` : ""}
@@ -56645,8 +57100,8 @@ ${methods.includes("delete") ? `  /**
 ${methods.includes("search") ? `  /**
    * Search ${name}s
    */
-  async search(query: string, params?: PaginatedRequest): Promise<PaginatedResponse<${name}>> {
-    const response = await apiClient.get<${name}ListResponse>(\`\${ROUTE.api}/search\`, {
+  async search(query: string, params?: PaginationParams): Promise<PaginatedResult<${name}>> {
+    const response = await apiClient.get<PaginatedResult<${name}>>(\`\${ROUTE.api}/search\`, {
       params: { q: query, ...params }
     });
     return response.data;
@@ -56707,28 +57162,23 @@ export interface ${name}UpdateRequest {
   isActive?: boolean;
 }
 
-export interface ${name}ListResponse {
-  items: ${name}[];
-  totalCount: number;
-  pageSize: number;
-  currentPage: number;
-  totalPages: number;
-}
-
-export interface PaginatedRequest {
+export interface PaginationParams {
   page?: number;
   pageSize?: number;
   sortBy?: string;
   sortDirection?: 'asc' | 'desc';
+  search?: string;
   filter?: string;
 }
 
-export interface PaginatedResponse<T> {
+export interface PaginatedResult<T> {
   items: T[];
   totalCount: number;
   pageSize: number;
-  currentPage: number;
+  page: number;
   totalPages: number;
+  hasPreviousPage: boolean;
+  hasNextPage: boolean;
 }
 `;
 }
@@ -56741,7 +57191,7 @@ function generateHook(name, nameLower, methods) {
 
 import { useQuery, useMutation, useQueryClient, UseQueryOptions, UseMutationOptions } from '@tanstack/react-query';
 import { ${nameLower}Api } from '../services/api/${nameLower}';
-import type { ${name}, ${name}CreateRequest, ${name}UpdateRequest, PaginatedRequest, PaginatedResponse } from '../types/${nameLower}';
+import type { ${name}, ${name}CreateRequest, ${name}UpdateRequest, PaginationParams, PaginatedResult } from '../types/${nameLower}';
 
 const QUERY_KEY = '${nameLower}s';
 
@@ -56749,8 +57199,8 @@ ${methods.includes("getAll") ? `/**
  * Hook to fetch paginated ${name} list
  */
 export function use${name}List(
-  params?: PaginatedRequest,
-  options?: Omit<UseQueryOptions<PaginatedResponse<${name}>>, 'queryKey' | 'queryFn'>
+  params?: PaginationParams,
+  options?: Omit<UseQueryOptions<PaginatedResult<${name}>>, 'queryKey' | 'queryFn'>
 ) {
   return useQuery({
     queryKey: [QUERY_KEY, 'list', params],
@@ -56831,8 +57281,8 @@ ${methods.includes("search") ? `/**
  */
 export function use${name}Search(
   query: string,
-  params?: PaginatedRequest,
-  options?: Omit<UseQueryOptions<PaginatedResponse<${name}>>, 'queryKey' | 'queryFn'>
+  params?: PaginationParams,
+  options?: Omit<UseQueryOptions<PaginatedResult<${name}>>, 'queryKey' | 'queryFn'>
 ) {
   return useQuery({
     queryKey: [QUERY_KEY, 'search', query, params],
@@ -57023,7 +57473,7 @@ async function scaffoldRoutes(input, config2) {
     result.instructions.push("import { PageLoader } from '@/components/ui/PageLoader';");
     result.instructions.push("");
     const importedComponents = /* @__PURE__ */ new Set();
-    for (const [context, applications] of Object.entries(routeTree)) {
+    for (const [_context, applications] of Object.entries(routeTree)) {
       for (const [, modules] of Object.entries(applications)) {
         for (const route of modules) {
           const pageEntry = pageFiles.get(route.navRoute);