[CLAUDE] Domain+Infra+App+Api+FE-Admin: versioned workflow per ContractType

User yêu cầu: mỗi loại HĐ có quy trình riêng với admin add roles + users
vào từng bước. Khi tạo version mới → HĐ tương lai chạy theo, HĐ cũ giữ
version cũ.

Domain:
- WorkflowDefinition (Code + Version + ContractType + IsActive + Steps)
- WorkflowStep (Order + Phase + Name + SlaDays + Approvers)
- WorkflowStepApprover (Kind: Role/User + AssignmentValue)
- Contract.WorkflowDefinitionId — pinned at creation
- WorkflowPolicyRegistry.FromDefinition() — build runtime policy từ DB

Infrastructure:
- EF config + migration AddVersionedWorkflows (3 table mới)
- DbInitializer.SeedWorkflowDefinitionsAsync: v01 per 7 ContractType,
  steps sinh từ hardcoded WorkflowPolicies (Role approvers).
- ContractWorkflowService.TransitionAsync: load pinned WorkflowDefinition
  → FromDefinition(), fallback cho HĐ cũ không có pin.

Application:
- CreateContractCommand pin WorkflowDefinitionId = active version cho type
- ContractFeatures.Get(id): load pinned def cho workflow summary
- WorkflowAdminFeatures: GetWorkflowAdminOverviewQuery (7 types + active
  + history + ContractsUsingCount), CreateWorkflowDefinitionCommand
  (validate payload, auto-increment version, deactivate old).

Api:
- GET /api/workflows trả overview
- POST /api/workflows tạo version mới (deactivate old)

FE /system/workflows:
- Tabs per 7 ContractType, mỗi tab hiện active version + lịch sử
- DefinitionCard: steps với badge role/user + SLA + archived indicator
  hiện "N HĐ còn chạy" cho version cũ
- WorkflowDesigner modal: form code/name/desc + danh sách steps
  (phase/name/SLA) + approvers (+ Role hoặc + User). Drop step ok.
  Clone từ version hiện tại để tạo v02 có điểm start sensible.
- Amber banner: HĐ cũ không bị ảnh hưởng khi tạo version mới

Invariants được giữ:
- Unique (Code, Version) index
- Chỉ 1 version IsActive per ContractType tại 1 thời điểm
- Set default sẽ auto xóa override → respect legacy override table
- Role-kind approvers drive transition guards; User-kind fallback
  DeptManager role cho v1 (user-level targeting = iteration 2)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

src/Backend/SolutionErp.Infrastructure/Persistence/ApplicationDbContext.cs

@@ -28,6 +28,9 @@ public class ApplicationDbContext
     public DbSet<ContractCodeSequence> ContractCodeSequences => Set<ContractCodeSequence>();
     public DbSet<Notification> Notifications => Set<Notification>();
     public DbSet<WorkflowTypeAssignment> WorkflowTypeAssignments => Set<WorkflowTypeAssignment>();
+    public DbSet<WorkflowDefinition> WorkflowDefinitions => Set<WorkflowDefinition>();
+    public DbSet<WorkflowStep> WorkflowSteps => Set<WorkflowStep>();
+    public DbSet<WorkflowStepApprover> WorkflowStepApprovers => Set<WorkflowStepApprover>();
 
     protected override void OnModelCreating(ModelBuilder builder)
     {

src/Backend/SolutionErp.Infrastructure/Persistence/Configurations/WorkflowDefinitionConfiguration.cs

@@ -0,0 +1,54 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using SolutionErp.Domain.Contracts;
+
+namespace SolutionErp.Infrastructure.Persistence.Configurations;
+
+public class WorkflowDefinitionConfiguration : IEntityTypeConfiguration<WorkflowDefinition>
+{
+    public void Configure(EntityTypeBuilder<WorkflowDefinition> e)
+    {
+        e.ToTable("WorkflowDefinitions");
+        e.Property(x => x.Code).HasMaxLength(100).IsRequired();
+        e.Property(x => x.Name).HasMaxLength(200).IsRequired();
+        e.Property(x => x.Description).HasMaxLength(1000);
+        e.Property(x => x.ContractType).HasConversion<int>();
+
+        // Unique (Code, Version) — prevents duplicate version numbers per code
+        e.HasIndex(x => new { x.Code, x.Version }).IsUnique();
+        // Helper index — "get active by type" hot path
+        e.HasIndex(x => new { x.ContractType, x.IsActive });
+    }
+}
+
+public class WorkflowStepConfiguration : IEntityTypeConfiguration<WorkflowStep>
+{
+    public void Configure(EntityTypeBuilder<WorkflowStep> e)
+    {
+        e.ToTable("WorkflowSteps");
+        e.Property(x => x.Name).HasMaxLength(200).IsRequired();
+        e.Property(x => x.Phase).HasConversion<int>();
+
+        e.HasOne(x => x.WorkflowDefinition)
+            .WithMany(d => d.Steps)
+            .HasForeignKey(x => x.WorkflowDefinitionId)
+            .OnDelete(DeleteBehavior.Cascade);
+
+        e.HasIndex(x => new { x.WorkflowDefinitionId, x.Order });
+    }
+}
+
+public class WorkflowStepApproverConfiguration : IEntityTypeConfiguration<WorkflowStepApprover>
+{
+    public void Configure(EntityTypeBuilder<WorkflowStepApprover> e)
+    {
+        e.ToTable("WorkflowStepApprovers");
+        e.Property(x => x.Kind).HasConversion<int>();
+        e.Property(x => x.AssignmentValue).HasMaxLength(100).IsRequired();
+
+        e.HasOne(x => x.Step)
+            .WithMany(s => s.Approvers)
+            .HasForeignKey(x => x.WorkflowStepId)
+            .OnDelete(DeleteBehavior.Cascade);
+    }
+}

src/Backend/SolutionErp.Infrastructure/Persistence/DbInitializer.cs

@@ -33,9 +33,88 @@ public static class DbInitializer
         await SeedDepartmentsAsync(db, logger);
         await SeedDemoMasterDataAsync(db, logger);
         await SeedContractTemplatesAsync(db, logger);
+        await SeedWorkflowDefinitionsAsync(db, logger);
         await WarnDefaultAdminPasswordAsync(userManager, logger);
     }
 
+    // Seed v01 per ContractType from hardcoded WorkflowPolicies. Idempotent:
+    // skip if any active definition already exists for that type (admin may
+    // have already created custom versions — don't clobber).
+    private static async Task SeedWorkflowDefinitionsAsync(ApplicationDbContext db, ILogger logger)
+    {
+        var typeLabels = new Dictionary<ContractType, (string Code, string Name)>
+        {
+            [ContractType.HopDongThauPhu]          = ("QT-TP",   "Quy trình HĐ Thầu phụ"),
+            [ContractType.HopDongGiaoKhoan]        = ("QT-GK",   "Quy trình HĐ Giao khoán"),
+            [ContractType.HopDongNhaCungCap]       = ("QT-NCC",  "Quy trình HĐ Nhà cung cấp"),
+            [ContractType.HopDongDichVu]           = ("QT-DV",   "Quy trình HĐ Dịch vụ"),
+            [ContractType.HopDongMuaBan]           = ("QT-MB",   "Quy trình HĐ Mua bán"),
+            [ContractType.HopDongNguyenTacNCC]     = ("QT-NTNCC","Quy trình HĐ Nguyên tắc NCC"),
+            [ContractType.HopDongNguyenTacDichVu]  = ("QT-NTDV", "Quy trình HĐ Nguyên tắc Dịch vụ"),
+        };
+
+        var phaseNames = new Dictionary<ContractPhase, string>
+        {
+            [ContractPhase.DangSoanThao]    = "Soạn thảo",
+            [ContractPhase.DangGopY]        = "Góp ý",
+            [ContractPhase.DangDamPhan]     = "Đàm phán",
+            [ContractPhase.DangInKy]        = "In ký",
+            [ContractPhase.DangKiemTraCCM]  = "Kiểm tra CCM",
+            [ContractPhase.DangTrinhKy]     = "Trình ký BOD",
+            [ContractPhase.DangDongDau]     = "Đóng dấu",
+            [ContractPhase.DaPhatHanh]      = "Phát hành",
+        };
+
+        var added = 0;
+        foreach (var (type, info) in typeLabels)
+        {
+            var alreadyExists = await db.WorkflowDefinitions.AnyAsync(w => w.ContractType == type);
+            if (alreadyExists) continue;
+
+            var policy = WorkflowPolicyRegistry.For(type);
+            var def = new WorkflowDefinition
+            {
+                Code = info.Code,
+                Version = 1,
+                ContractType = type,
+                Name = $"{info.Name} (v01)",
+                Description = policy.Description,
+                IsActive = true,
+                ActivatedAt = DateTime.UtcNow,
+                Steps = policy.ActivePhases
+                    .Where(p => p != ContractPhase.TuChoi)  // TuChoi is a terminal state, not a step
+                    .Select((p, idx) =>
+                    {
+                        var roles = policy.Transitions
+                            .Where(t => t.Key.To == p)
+                            .SelectMany(t => t.Value)
+                            .Distinct()
+                            .ToList();
+                        return new WorkflowStep
+                        {
+                            Order = idx + 1,
+                            Phase = p,
+                            Name = phaseNames.GetValueOrDefault(p, p.ToString()),
+                            SlaDays = policy.PhaseSla.GetValueOrDefault(p) is TimeSpan s ? (int?)s.Days : null,
+                            Approvers = roles.Select(r => new WorkflowStepApprover
+                            {
+                                Kind = WorkflowApproverKind.Role,
+                                AssignmentValue = r,
+                            }).ToList(),
+                        };
+                    })
+                    .ToList(),
+            };
+            db.WorkflowDefinitions.Add(def);
+            added++;
+        }
+        if (added > 0)
+        {
+            await db.SaveChangesAsync();
+            logger.LogInformation("Seeded {Count} workflow definitions (v01)", added);
+        }
+    }
+
     // Phase 5.1 security: log warning nếu admin vẫn dùng password mặc định sau deploy production.
     private static async Task WarnDefaultAdminPasswordAsync(UserManager<User> userManager, ILogger logger)
     {

src/Backend/SolutionErp.Infrastructure/Persistence/Migrations/20260421155557_AddVersionedWorkflows.cs

@@ -0,0 +1,131 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace SolutionErp.Infrastructure.Persistence.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddVersionedWorkflows : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<Guid>(
+                name: "WorkflowDefinitionId",
+                table: "Contracts",
+                type: "uniqueidentifier",
+                nullable: true);
+
+            migrationBuilder.CreateTable(
+                name: "WorkflowDefinitions",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
+                    Code = table.Column<string>(type: "nvarchar(100)", maxLength: 100, nullable: false),
+                    Version = table.Column<int>(type: "int", nullable: false),
+                    ContractType = table.Column<int>(type: "int", nullable: false),
+                    Name = table.Column<string>(type: "nvarchar(200)", maxLength: 200, nullable: false),
+                    Description = table.Column<string>(type: "nvarchar(1000)", maxLength: 1000, nullable: true),
+                    IsActive = table.Column<bool>(type: "bit", nullable: false),
+                    ActivatedAt = table.Column<DateTime>(type: "datetime2", nullable: true),
+                    CreatedAt = table.Column<DateTime>(type: "datetime2", nullable: false),
+                    UpdatedAt = table.Column<DateTime>(type: "datetime2", nullable: true),
+                    CreatedBy = table.Column<Guid>(type: "uniqueidentifier", nullable: true),
+                    UpdatedBy = table.Column<Guid>(type: "uniqueidentifier", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_WorkflowDefinitions", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "WorkflowSteps",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
+                    WorkflowDefinitionId = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
+                    Order = table.Column<int>(type: "int", nullable: false),
+                    Phase = table.Column<int>(type: "int", nullable: false),
+                    Name = table.Column<string>(type: "nvarchar(200)", maxLength: 200, nullable: false),
+                    SlaDays = table.Column<int>(type: "int", nullable: true),
+                    CreatedAt = table.Column<DateTime>(type: "datetime2", nullable: false),
+                    UpdatedAt = table.Column<DateTime>(type: "datetime2", nullable: true),
+                    CreatedBy = table.Column<Guid>(type: "uniqueidentifier", nullable: true),
+                    UpdatedBy = table.Column<Guid>(type: "uniqueidentifier", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_WorkflowSteps", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_WorkflowSteps_WorkflowDefinitions_WorkflowDefinitionId",
+                        column: x => x.WorkflowDefinitionId,
+                        principalTable: "WorkflowDefinitions",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "WorkflowStepApprovers",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
+                    WorkflowStepId = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
+                    Kind = table.Column<int>(type: "int", nullable: false),
+                    AssignmentValue = table.Column<string>(type: "nvarchar(100)", maxLength: 100, nullable: false),
+                    CreatedAt = table.Column<DateTime>(type: "datetime2", nullable: false),
+                    UpdatedAt = table.Column<DateTime>(type: "datetime2", nullable: true),
+                    CreatedBy = table.Column<Guid>(type: "uniqueidentifier", nullable: true),
+                    UpdatedBy = table.Column<Guid>(type: "uniqueidentifier", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_WorkflowStepApprovers", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_WorkflowStepApprovers_WorkflowSteps_WorkflowStepId",
+                        column: x => x.WorkflowStepId,
+                        principalTable: "WorkflowSteps",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_WorkflowDefinitions_Code_Version",
+                table: "WorkflowDefinitions",
+                columns: new[] { "Code", "Version" },
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_WorkflowDefinitions_ContractType_IsActive",
+                table: "WorkflowDefinitions",
+                columns: new[] { "ContractType", "IsActive" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_WorkflowStepApprovers_WorkflowStepId",
+                table: "WorkflowStepApprovers",
+                column: "WorkflowStepId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_WorkflowSteps_WorkflowDefinitionId_Order",
+                table: "WorkflowSteps",
+                columns: new[] { "WorkflowDefinitionId", "Order" });
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "WorkflowStepApprovers");
+
+            migrationBuilder.DropTable(
+                name: "WorkflowSteps");
+
+            migrationBuilder.DropTable(
+                name: "WorkflowDefinitions");
+
+            migrationBuilder.DropColumn(
+                name: "WorkflowDefinitionId",
+                table: "Contracts");
+        }
+    }
+}

src/Backend/SolutionErp.Infrastructure/Persistence/Migrations/ApplicationDbContextModelSnapshot.cs

@@ -201,6 +201,9 @@ namespace SolutionErp.Infrastructure.Persistence.Migrations
                     b.Property<Guid?>("UpdatedBy")
                         .HasColumnType("uniqueidentifier");
 
+                    b.Property<Guid?>("WorkflowDefinitionId")
+                        .HasColumnType("uniqueidentifier");
+
                     b.HasKey("Id");
 
                     b.HasIndex("MaHopDong")
@@ -374,6 +377,138 @@ namespace SolutionErp.Infrastructure.Persistence.Migrations
                     b.ToTable("ContractComments", (string)null);
                 });
 
+            modelBuilder.Entity("SolutionErp.Domain.Contracts.WorkflowDefinition", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime?>("ActivatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<int>("ContractType")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid?>("CreatedBy")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid?>("UpdatedBy")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Version")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code", "Version")
+                        .IsUnique();
+
+                    b.HasIndex("ContractType", "IsActive");
+
+                    b.ToTable("WorkflowDefinitions", (string)null);
+                });
+
+            modelBuilder.Entity("SolutionErp.Domain.Contracts.WorkflowStep", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid?>("CreatedBy")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int>("Order")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Phase")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SlaDays")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid?>("UpdatedBy")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("WorkflowDefinitionId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorkflowDefinitionId", "Order");
+
+                    b.ToTable("WorkflowSteps", (string)null);
+                });
+
+            modelBuilder.Entity("SolutionErp.Domain.Contracts.WorkflowStepApprover", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("AssignmentValue")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid?>("CreatedBy")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Kind")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<Guid?>("UpdatedBy")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("WorkflowStepId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorkflowStepId");
+
+                    b.ToTable("WorkflowStepApprovers", (string)null);
+                });
+
             modelBuilder.Entity("SolutionErp.Domain.Contracts.WorkflowTypeAssignment", b =>
                 {
                     b.Property<Guid>("Id")
@@ -1049,6 +1184,28 @@ namespace SolutionErp.Infrastructure.Persistence.Migrations
                     b.Navigation("Contract");
                 });
 
+            modelBuilder.Entity("SolutionErp.Domain.Contracts.WorkflowStep", b =>
+                {
+                    b.HasOne("SolutionErp.Domain.Contracts.WorkflowDefinition", "WorkflowDefinition")
+                        .WithMany("Steps")
+                        .HasForeignKey("WorkflowDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("WorkflowDefinition");
+                });
+
+            modelBuilder.Entity("SolutionErp.Domain.Contracts.WorkflowStepApprover", b =>
+                {
+                    b.HasOne("SolutionErp.Domain.Contracts.WorkflowStep", "Step")
+                        .WithMany("Approvers")
+                        .HasForeignKey("WorkflowStepId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Step");
+                });
+
             modelBuilder.Entity("SolutionErp.Domain.Identity.MenuItem", b =>
                 {
                     b.HasOne("SolutionErp.Domain.Identity.MenuItem", "Parent")
@@ -1087,6 +1244,16 @@ namespace SolutionErp.Infrastructure.Persistence.Migrations
                     b.Navigation("Comments");
                 });
 
+            modelBuilder.Entity("SolutionErp.Domain.Contracts.WorkflowDefinition", b =>
+                {
+                    b.Navigation("Steps");
+                });
+
+            modelBuilder.Entity("SolutionErp.Domain.Contracts.WorkflowStep", b =>
+                {
+                    b.Navigation("Approvers");
+                });
+
             modelBuilder.Entity("SolutionErp.Domain.Identity.MenuItem", b =>
                 {
                     b.Navigation("Children");

src/Backend/SolutionErp.Infrastructure/Services/ContractWorkflowService.cs

@@ -36,11 +36,26 @@ public class ContractWorkflowService(
         if (contract.Phase == targetPhase)
             throw new ConflictException("HĐ đã ở phase đích.");
 
-        // Admin may override the default policy per ContractType via the
-        // /system/workflows page. Load all overrides once (7 rows max).
-        var overrides = await db.WorkflowTypeAssignments.AsNoTracking()
-            .ToDictionaryAsync(a => a.ContractType, a => a.PolicyName, ct);
-        var policy = WorkflowPolicyRegistry.ForContractWithOverrides(contract, overrides);
+        // Resolve the workflow: prefer the pinned WorkflowDefinition (new
+        // versioned system), else fall back to the static/override registry
+        // (legacy path for contracts created before versioning rolled out).
+        WorkflowPolicy policy;
+        if (contract.WorkflowDefinitionId is Guid wfId)
+        {
+            var def = await db.WorkflowDefinitions.AsNoTracking()
+                .Include(d => d.Steps.OrderBy(s => s.Order))
+                    .ThenInclude(s => s.Approvers)
+                .FirstOrDefaultAsync(d => d.Id == wfId, ct);
+            policy = def is not null
+                ? WorkflowPolicyRegistry.FromDefinition(def)
+                : WorkflowPolicyRegistry.ForContract(contract);
+        }
+        else
+        {
+            var overrides = await db.WorkflowTypeAssignments.AsNoTracking()
+                .ToDictionaryAsync(a => a.ContractType, a => a.PolicyName, ct);
+            policy = WorkflowPolicyRegistry.ForContractWithOverrides(contract, overrides);
+        }
         var isAdmin = actorRoles.Contains(AppRoles.Admin);
         var isSystem = actorUserId is null && decision == ApprovalDecision.AutoApprove;