Merge ba8907fad0 into 782165a4cf

Storing the submitted full name in FirstName while leaving a seeded
LastName intact made an unchanged save project a duplicated name
(e.g. "Legacy Manager Manager"). Leave FirstName/LastName untouched when
the submitted name already matches the stored first+last projection, and
otherwise split the submitted name across FirstName/LastName so renames
round-trip cleanly.

Api.SeaHavenIndustries.Tests/DashboardControllerTests.cs

@@ -0,0 +1,54 @@
+using System.Security.Claims;
+using Api.SeaHavenIndustries.Controllers;
+using FluentAssertions;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using SeaHaven.Services.DTOs;
+using SeaHaven.Services.Interfaces;
+using Xunit;
+
+namespace Api.SeaHavenIndustries.Tests;
+
+public class DashboardControllerTests
+{
+    private static object Prop(object source, string name) =>
+        source.GetType().GetProperty(name)!.GetValue(source)!;
+
+    private static DashboardController NewController(Mock<IDashboardService> service) =>
+        new(service.Object)
+        {
+            ControllerContext = new ControllerContext
+            {
+                HttpContext = new DefaultHttpContext()
+            }
+        };
+
+    // Guards the Stats wire object, not the service DTO. GetKpiCountsAsync and
+    // DashboardStatsDTO already carried these three counts; the regression this
+    // pins is the controller's anonymous response silently dropping them, which
+    // is what left the tiles with nothing to read.
+    [Fact]
+    public async Task GetStats_SerialisesKpiCountsOnWireObject()
+    {
+        var service = new Mock<IDashboardService>();
+        service.Setup(s => s.GetStatsAsync(
+                It.IsAny<ClaimsPrincipal>(),
+                It.IsAny<DashboardStatsQueryDTO>(),
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new DashboardStatsDTO
+            {
+                ScheduledTomorrow = 3,
+                PendingUplifts = 5,
+                AvetaPending = 7
+            });
+
+        var result = await NewController(service).GetStats(
+            new DashboardStatsQueryDTO(), CancellationToken.None);
+
+        var body = result.Should().BeOfType<OkObjectResult>().Subject.Value!;
+        ((int)Prop(body, "scheduledTomorrow")).Should().Be(3);
+        ((int)Prop(body, "pendingUplifts")).Should().Be(5);
+        ((int)Prop(body, "avetaPending")).Should().Be(7);
+    }
+}

Api.SeaHavenIndustries.Tests/DashboardServiceTests.cs

@@ -99,6 +99,55 @@ public class DashboardServiceTests
         stats.Completed.Should().Be(1);
     }
 
+    [Fact]
+    public async Task GetStatsAsync_ExposesKpiCounts_PendingUpliftsCountsPendingStatusOnly()
+    {
+        using var ctx = NewContext();
+        var today = DashboardBusinessTime.Today();
+        var tomorrow = today.AddDays(1);
+
+        // Scheduled-tomorrow tile: one account-1 order scheduled for tomorrow.
+        ctx.workOrders.Add(new WorkOrder
+        {
+            AccountId = 1,
+            LifecycleStatus = Data.SeaHavenIndustries.Enums.LifecycleStatus.Scheduled,
+            ScheduledDate = tomorrow.ToDateTime(TimeOnly.MinValue)
+        });
+
+        // Aveta-pending tile: Aveta-required order in the today/tomorrow window
+        // with no Aveta attachment. Its Dispatch anchors the uplift requests below.
+        var avetaOrder = new WorkOrder
+        {
+            AccountId = 1,
+            AvetaRequired = true,
+            LifecycleStatus = Data.SeaHavenIndustries.Enums.LifecycleStatus.Scheduled,
+            ScheduledDate = today.ToDateTime(TimeOnly.MinValue)
+        };
+        ctx.workOrders.Add(avetaOrder);
+        ctx.SaveChanges();
+
+        var dispatch = new Dispatch { WorkOrderId = avetaOrder.Id, IsDeleted = false };
+        ctx.Set<Dispatch>().Add(dispatch);
+        ctx.SaveChanges();
+
+        // Pending-uplifts tile: only Status == "Pending" is an outstanding uplift
+        // awaiting an approval decision. This test pins the behaviour the code
+        // ships today: a "ChangesRequested" request has been sent back to the
+        // vendor, so it is NOT counted. Whether pendingUplifts should also include
+        // ChangesRequested is an open product call, not a settled review decision.
+        ctx.Set<DispatchUpliftRequest>().AddRange(
+            new DispatchUpliftRequest { DispatchId = dispatch.Id, Status = "Pending", IsDeleted = false },
+            new DispatchUpliftRequest { DispatchId = dispatch.Id, Status = "ChangesRequested", IsDeleted = false });
+        ctx.SaveChanges();
+
+        var stats = await NewService(ctx).GetStatsAsync(
+            AccountUser(1), new DashboardStatsQueryDTO(), CancellationToken.None);
+
+        stats.ScheduledTomorrow.Should().Be(1);
+        stats.AvetaPending.Should().Be(1);
+        stats.PendingUplifts.Should().Be(1);
+    }
+
     [Fact]
     public async Task GetStatsAsync_MissingScopeFailsClosed()
     {
@@ -309,11 +358,17 @@ public class DashboardServiceTests
         ctx.Locations.AddRange(
             new Locations { Id = 1, State = "NY" },
             new Locations { Id = 2, State = "ca" },
-            new Locations { Id = 3, State = "XX" });
+            new Locations { Id = 3, State = "XX" },
+            new Locations { Id = 4, State = "indiana" },
+            new Locations { Id = 5, State = "NEW YORK" },
+            new Locations { Id = 6, State = "California" });
         ctx.workOrders.AddRange(
             new WorkOrder { AccountId = 1, LocationId = 1 },
             new WorkOrder { AccountId = 1, LocationId = 2 },
             new WorkOrder { AccountId = 1, LocationId = 3 },
+            new WorkOrder { AccountId = 1, LocationId = 4 },
+            new WorkOrder { AccountId = 1, LocationId = 5 },
+            new WorkOrder { AccountId = 1, LocationId = 6 },
             new WorkOrder { AccountId = 1, LocationId = null });
         await ctx.SaveChangesAsync();
 
@@ -322,7 +377,28 @@ public class DashboardServiceTests
 
         result.Items.Select(row => row.Region).Should().Equal(
             "East", "Central", "West", "California", "Unmapped/Other");
-        result.Items.Select(row => row.WorkOrderCount).Should().Equal(1, 0, 0, 1, 2);
+        // NY + "NEW YORK" -> East; "indiana" -> Central; "ca" + "California" -> California;
+        // "XX" + unassigned location -> Unmapped/Other. Full-name storage forms must not
+        // fall through to Unmapped/Other (SH-348 review).
+        result.Items.Select(row => row.WorkOrderCount).Should().Equal(2, 1, 0, 2, 2);
+    }
+
+    [Fact]
+    public void Resolve_MapsEveryUsStateAndItsFullNameToACanonicalBucket()
+    {
+        foreach (var code in UsStateCodes.All)
+        {
+            var byCode = DashboardRegions.Resolve(code);
+            byCode.Should().NotBe(
+                "Unmapped/Other",
+                $"state code {code} must belong to a canonical region");
+
+            var fullName = UsStateCodes.ExpandStorageValues(new[] { code })
+                .First(value => value != code);
+            DashboardRegions.Resolve(fullName).Should().Be(
+                byCode,
+                $"the full-name storage form of {code} must resolve to the same region as the code");
+        }
     }
 
     [Fact]

Api.SeaHavenIndustries.Tests/LocationControllerTests.cs

@@ -26,7 +26,7 @@ public class LocationControllerTests
     public async Task GetLocationList_ReturnsPaginationEnvelopeWithServiceData()
     {
         var service = new Mock<ILocationService>();
-        service.Setup(s => s.GetLocationListPagedAsync(1, 10, "a", null, It.IsAny<CancellationToken>()))
+        service.Setup(s => s.GetLocationListPagedAsync(1, 10, "a", null, It.IsAny<CancellationToken>(), It.IsAny<string?>(), It.IsAny<string?>()))
                .ReturnsAsync(new PagedResult<LocationDTO>
                {
                    Items = new List<LocationDTO> { new() { Id = 1, Name = "Site" } },
@@ -49,7 +49,7 @@ public class LocationControllerTests
     public async Task GetLocationList_PassesStatesFilterToService()
     {
         var service = new Mock<ILocationService>();
-        service.Setup(s => s.GetLocationListPagedAsync(1, 10, null, "tx, mo", It.IsAny<CancellationToken>()))
+        service.Setup(s => s.GetLocationListPagedAsync(1, 10, null, "tx, mo", It.IsAny<CancellationToken>(), It.IsAny<string?>(), It.IsAny<string?>()))
                .ReturnsAsync(new PagedResult<LocationDTO>
                {
                    Items = new List<LocationDTO>(),
@@ -58,7 +58,7 @@ public class LocationControllerTests
                    PageSize = 10
                });
 
-        var result = await NewController(service).GetLocationList(null, 1, 10, "tx, mo", CancellationToken.None);
+        var result = await NewController(service).GetLocationList(null, 1, 10, "tx, mo", cancellationToken: CancellationToken.None);
 
         result.Should().BeOfType<OkObjectResult>();
         service.VerifyAll();
@@ -68,13 +68,13 @@ public class LocationControllerTests
     public async Task GetLocationList_WhenStatesInvalid_ReturnsExistingValidationErrorShape()
     {
         var service = new Mock<ILocationService>();
-        service.Setup(s => s.GetLocationListPagedAsync(It.IsAny<int>(), It.IsAny<int>(), It.IsAny<string?>(), It.IsAny<string?>(), It.IsAny<CancellationToken>()))
+        service.Setup(s => s.GetLocationListPagedAsync(It.IsAny<int>(), It.IsAny<int>(), It.IsAny<string?>(), It.IsAny<string?>(), It.IsAny<CancellationToken>(), It.IsAny<string?>(), It.IsAny<string?>()))
                .ThrowsAsync(new ValidationException(new[]
                {
                    new ValidationFailure("states", "states must be valid US postal abbreviations: ZZ.")
                }));
 
-        var result = await NewController(service).GetLocationList(null, 1, 10, "ZZ", CancellationToken.None);
+        var result = await NewController(service).GetLocationList(null, 1, 10, "ZZ", cancellationToken: CancellationToken.None);
 
         var bad = result.Should().BeOfType<BadRequestObjectResult>().Subject;
         var response = bad.Value.Should().BeOfType<Response>().Subject;
@@ -200,4 +200,90 @@ public class LocationControllerTests
         var notFound = result.Should().BeOfType<NotFoundObjectResult>().Subject;
         notFound.Value.Should().BeOfType<Response>().Subject.Message.Should().Be("Location not found");
     }
+
+    [Fact]
+    public async Task GetLocationList_ForwardsSortParamsToService()
+    {
+        var service = new Mock<ILocationService>();
+        service.Setup(s => s.GetLocationListPagedAsync(1, 10, "", null, It.IsAny<CancellationToken>(), "city", "desc"))
+               .ReturnsAsync(new PagedResult<LocationDTO> { Items = new List<LocationDTO>(), TotalCount = 0, Page = 1, PageSize = 10 });
+
+        await NewController(service).GetLocationList(sortBy: "city", sortDirection: "desc", cancellationToken: CancellationToken.None);
+
+        service.Verify(s => s.GetLocationListPagedAsync(1, 10, "", null, It.IsAny<CancellationToken>(), "city", "desc"), Times.Once);
+    }
+
+    [Fact]
+    public async Task GetLocationList_WhenSortInvalid_ReturnsExistingValidationErrorShape()
+    {
+        var service = new Mock<ILocationService>();
+        service.Setup(s => s.GetLocationListPagedAsync(It.IsAny<int>(), It.IsAny<int>(), It.IsAny<string?>(), It.IsAny<string?>(), It.IsAny<CancellationToken>(), It.IsAny<string?>(), It.IsAny<string?>()))
+               .ThrowsAsync(new ValidationException(new[]
+               {
+                   new ValidationFailure("sortBy", "sortBy must be one of: code, client, address, city, state, poc.")
+               }));
+
+        var result = await NewController(service).GetLocationList(sortBy: "nope", cancellationToken: CancellationToken.None);
+
+        var bad = result.Should().BeOfType<BadRequestObjectResult>().Subject;
+        var response = bad.Value.Should().BeOfType<Response>().Subject;
+        response.Status.Should().Be("Validation Error");
+        response.Message.Should().Contain("sortBy");
+    }
+
+    [Fact]
+    public async Task GetLocationList_ProjectsClientAccountNameAndSiteFields()
+    {
+        var service = new Mock<ILocationService>();
+        service.Setup(s => s.GetLocationListPagedAsync(1, 10, "", null, It.IsAny<CancellationToken>(), null, null))
+               .ReturnsAsync(new PagedResult<LocationDTO>
+               {
+                   Items = new List<LocationDTO>
+                   {
+                       new()
+                       {
+                           Id = 1,
+                           Name = "STL8",
+                           Address1 = "9 River Rd",
+                           City = "St. Louis",
+                           State = "MO",
+                           Zip = "63101",
+                           PhoneNumber = "555-0100",
+                           Email = "poc@example.com",
+                           AccountId = 3,
+                           AccountName = "Acme Co",
+                           Contacts = new List<SiteContactResponseDTO>
+                           {
+                               new() { Id = 10, Name = "Cara Lane", Phone = "555-0100" },
+                               new() { Id = 11, Name = "Alan Ford", Phone = "555-0101" }
+                           }
+                       }
+                   },
+                   TotalCount = 1,
+                   Page = 1,
+                   PageSize = 10
+               });
+
+        var result = await NewController(service).GetLocationList(cancellationToken: CancellationToken.None);
+
+        var ok = result.Should().BeOfType<OkObjectResult>().Subject;
+        using var json = System.Text.Json.JsonSerializer.SerializeToDocument(ok.Value);
+        var row = json.RootElement.GetProperty("Data").EnumerateArray().Single();
+
+        row.GetProperty("Name").GetString().Should().Be("STL8", "the site code is the legacy Name field");
+        row.GetProperty("Address").GetString().Should().Be("9 River Rd");
+        row.GetProperty("City").GetString().Should().Be("St. Louis");
+        row.GetProperty("State").GetString().Should().Be("MO");
+        row.GetProperty("ZipCode").GetString().Should().Be("63101");
+        row.GetProperty("Phone").GetString().Should().Be("555-0100");
+        row.GetProperty("ContactEmail").GetString().Should().Be("poc@example.com");
+        row.GetProperty("Contact").GetString().Should().Be("Cara Lane", "the first ordered contact is the legacy Contact field");
+        row.GetProperty("AccountId").GetInt32().Should().Be(3);
+        row.GetProperty("ClientName").GetString().Should().Be("Acme Co");
+        row.GetProperty("AccountName").GetString().Should().Be("Acme Co");
+        var contacts = row.GetProperty("Contacts");
+        contacts.GetArrayLength().Should().Be(2);
+        contacts[0].GetProperty("Name").GetString().Should().Be("Cara Lane");
+        contacts[1].GetProperty("Name").GetString().Should().Be("Alan Ford");
+    }
 }

Api.SeaHavenIndustries.Tests/LocationDataServiceTests.cs

@@ -86,4 +86,129 @@ public class LocationDataServiceTests
         totalCount.Should().Be(2);
         items.Select(l => l.State).Should().BeEquivalentTo("indiana", "MO");
     }
+
+    private static async Task SeedRegistryAsync(ApplicationDbContext ctx)
+    {
+        ctx.Accounts.AddRange(
+            new Accounts { Id = 1, Name = "Acme Co", IsDeleted = false },
+            new Accounts { Id = 2, Name = "Borealis LLC", IsDeleted = false });
+        ctx.Locations.AddRange(
+            new Locations { Id = 10, Name = "STL8", Address1 = "9 River Rd", City = "St. Louis", State = "MO", AccountId = 1 },
+            new Locations { Id = 11, Name = "DFW8", Address1 = "2 Prairie Ave", City = "Dallas", State = "TX", AccountId = 2 },
+            new Locations { Id = 12, Name = "IND9", Address1 = "5 Circle Blvd", City = "Indianapolis", State = "IN", AccountId = 1 },
+            new Locations { Id = 13, Name = "MIA2", Address1 = "1 Bay Dr", City = "Miami", State = "FL", AccountId = 2 });
+        ctx.Contacts.AddRange(
+            new Contacts { Id = 100, LocationId = 10, SiteContactOrder = 0, FirstName = "Cara Lane", PhoneNumber = "555-0001" },
+            new Contacts { Id = 101, LocationId = 10, SiteContactOrder = 1, FirstName = "Alan Ford", PhoneNumber = "555-0002" },
+            new Contacts { Id = 102, LocationId = 11, SiteContactOrder = 1, FirstName = "Zoe Park", PhoneNumber = "555-0003" },
+            new Contacts { Id = 103, LocationId = 11, SiteContactOrder = 0, FirstName = "Removed Poc", PhoneNumber = "555-0004", IsDeleted = true },
+            new Contacts { Id = 104, LocationId = 12, SiteContactOrder = 0, FirstName = "Bob Quinn", PhoneNumber = "555-0005" });
+        await ctx.SaveChangesAsync();
+    }
+
+    [Theory]
+    [InlineData("STL", new[] { 10 }, "site code")]
+    [InlineData("Borealis", new[] { 11, 13 }, "client name")]
+    [InlineData("Prairie", new[] { 11 }, "street address")]
+    [InlineData("Miami", new[] { 13 }, "city")]
+    public async Task GetListPagedAsync_SearchMatchesCodeClientAddressAndCity(string term, int[] expectedIds, string becauseField)
+    {
+        await using var ctx = NewContext();
+        await SeedRegistryAsync(ctx);
+
+        var (items, totalCount) = await new LocationDataService(ctx)
+            .GetListPagedAsync(1, 10, term, null, CancellationToken.None);
+
+        totalCount.Should().Be(expectedIds.Length, $"search must match the {becauseField}");
+        items.Select(l => l.Id).Should().BeEquivalentTo(expectedIds);
+    }
+
+    [Theory]
+    [InlineData("code", 11, 12, 13, 10)]
+    [InlineData("client", 10, 12, 11, 13)]
+    [InlineData("address", 13, 11, 12, 10)]
+    [InlineData("city", 11, 12, 13, 10)]
+    [InlineData("state", 13, 12, 10, 11)]
+    [InlineData("poc", 13, 12, 10, 11)]
+    public async Task GetListPagedAsync_SortByAllowlistedColumn_OrdersAscending_WithIdTiebreak(
+        string sortBy, params int[] expectedIds)
+    {
+        await using var ctx = NewContext();
+        await SeedRegistryAsync(ctx);
+
+        var (items, _) = await new LocationDataService(ctx)
+            .GetListPagedAsync(1, 10, null, null, CancellationToken.None, sortBy, "asc");
+
+        items.Select(l => l.Id).Should().ContainInOrder(expectedIds);
+    }
+
+    [Fact]
+    public async Task GetListPagedAsync_SortByPoc_IgnoresDeletedContacts_AndSortsByFirstActiveContact()
+    {
+        await using var ctx = NewContext();
+        await SeedRegistryAsync(ctx);
+
+        var (items, _) = await new LocationDataService(ctx)
+            .GetListPagedAsync(1, 10, null, null, CancellationToken.None, "poc", "asc");
+
+        // DFW8's order-0 row is soft deleted, so its POC is "Zoe Park" (order 1) and it must
+        // sort last; including the deleted row ("Removed Poc") would instead place it second.
+        items.Select(l => l.Id).Should().ContainInOrder(13, 12, 10, 11);
+    }
+
+    [Fact]
+    public async Task GetListPagedAsync_SortByClient_Desc_ReversesAccountOrder()
+    {
+        await using var ctx = NewContext();
+        await SeedRegistryAsync(ctx);
+
+        var (items, _) = await new LocationDataService(ctx)
+            .GetListPagedAsync(1, 10, null, null, CancellationToken.None, "client", "desc");
+
+        items.Select(l => l.Id).Should().ContainInOrder(new[] { 11, 13, 10, 12 });
+    }
+
+    [Fact]
+    public async Task GetListPagedAsync_UnknownSortColumn_FallsBackToLegacyCodeOrder()
+    {
+        await using var ctx = NewContext();
+        await SeedRegistryAsync(ctx);
+
+        var (items, _) = await new LocationDataService(ctx)
+            .GetListPagedAsync(1, 10, null, null, CancellationToken.None, "not-a-column", "sideways");
+
+        items.Select(l => l.Name).Should().ContainInOrder("DFW8", "IND9", "MIA2", "STL8");
+    }
+
+    [Fact]
+    public async Task GetListPagedAsync_EqualSortValues_BreakTiesById_AcrossPages()
+    {
+        await using var ctx = NewContext();
+        ctx.Locations.AddRange(
+            new Locations { Id = 20, Name = "HOU1", City = "Dallas" },
+            new Locations { Id = 21, Name = "AUS3", City = "Dallas" },
+            new Locations { Id = 22, Name = "ELP4", City = "Dallas" });
+        await ctx.SaveChangesAsync();
+
+        var service = new LocationDataService(ctx);
+
+        var (page1, totalCount) = await service.GetListPagedAsync(1, 2, null, null, CancellationToken.None, "city", "asc");
+        var (page2, _) = await service.GetListPagedAsync(2, 2, null, null, CancellationToken.None, "city", "asc");
+
+        totalCount.Should().Be(3);
+        page1.Select(l => l.Id).Should().ContainInOrder(20, 21);
+        page2.Select(l => l.Id).Should().ContainInOrder(22);
+    }
+
+    [Fact]
+    public async Task GetListPagedAsync_ListLoadIncludesAccountNameForProjection()
+    {
+        await using var ctx = NewContext();
+        await SeedRegistryAsync(ctx);
+
+        var (items, _) = await new LocationDataService(ctx)
+            .GetListPagedAsync(1, 10, null, null, CancellationToken.None);
+
+        items.Single(l => l.Id == 10).Account!.Name.Should().Be("Acme Co");
+    }
 }

Api.SeaHavenIndustries.Tests/LocationServiceTests.cs

@@ -131,8 +131,8 @@ public class LocationServiceTests
     {
         var data = new Mock<ILocationDataService>();
         IReadOnlyCollection<string>? captured = default;
-        data.Setup(d => d.GetListPagedAsync(1, 10, null, It.IsAny<IReadOnlyCollection<string>?>(), It.IsAny<CancellationToken>()))
-            .Callback<int, int, string?, IReadOnlyCollection<string>?, CancellationToken>((_, _, _, states, _) => captured = states)
+        data.Setup(d => d.GetListPagedAsync(1, 10, null, It.IsAny<IReadOnlyCollection<string>?>(), It.IsAny<CancellationToken>(), It.IsAny<string?>(), It.IsAny<string?>()))
+            .Callback<int, int, string?, IReadOnlyCollection<string>?, CancellationToken, string?, string?>((_, _, _, states, _, _, _) => captured = states)
             .ReturnsAsync((new List<Locations>(), 0));
 
         await NewServiceWithSpy(data.Object).GetLocationListPagedAsync(1, 10, null, " tx , Mo ,,TX,  ", CancellationToken.None);
@@ -149,8 +149,8 @@ public class LocationServiceTests
         {
             var data = new Mock<ILocationDataService>();
             IReadOnlyCollection<string>? captured = default;
-            data.Setup(d => d.GetListPagedAsync(It.IsAny<int>(), It.IsAny<int>(), It.IsAny<string?>(), It.IsAny<IReadOnlyCollection<string>?>(), It.IsAny<CancellationToken>()))
-                .Callback<int, int, string?, IReadOnlyCollection<string>?, CancellationToken>((_, _, _, stateFilter, _) => captured = stateFilter)
+            data.Setup(d => d.GetListPagedAsync(It.IsAny<int>(), It.IsAny<int>(), It.IsAny<string?>(), It.IsAny<IReadOnlyCollection<string>?>(), It.IsAny<CancellationToken>(), It.IsAny<string?>(), It.IsAny<string?>()))
+                .Callback<int, int, string?, IReadOnlyCollection<string>?, CancellationToken, string?, string?>((_, _, _, stateFilter, _, _, _) => captured = stateFilter)
                 .ReturnsAsync((new List<Locations>(), 0));
 
             var page = await NewServiceWithSpy(data.Object).GetLocationListPagedAsync(1, 10, "search", states, CancellationToken.None);
@@ -173,14 +173,14 @@ public class LocationServiceTests
                 && e.ErrorMessage.Contains("ZZ")
                 && e.ErrorMessage.Contains("QQ")
                 && !e.ErrorMessage.Contains("TX"));
-        data.Verify(d => d.GetListPagedAsync(It.IsAny<int>(), It.IsAny<int>(), It.IsAny<string?>(), It.IsAny<IReadOnlyCollection<string>?>(), It.IsAny<CancellationToken>()), Times.Never);
+        data.Verify(d => d.GetListPagedAsync(It.IsAny<int>(), It.IsAny<int>(), It.IsAny<string?>(), It.IsAny<IReadOnlyCollection<string>?>(), It.IsAny<CancellationToken>(), It.IsAny<string?>(), It.IsAny<string?>()), Times.Never);
     }
 
     [Fact]
     public async Task GetLocationListPagedAsync_AcceptsAllFiftyStateCodes()
     {
         var data = new Mock<ILocationDataService>();
-        data.Setup(d => d.GetListPagedAsync(It.IsAny<int>(), It.IsAny<int>(), It.IsAny<string?>(), It.IsAny<IReadOnlyCollection<string>?>(), It.IsAny<CancellationToken>()))
+        data.Setup(d => d.GetListPagedAsync(It.IsAny<int>(), It.IsAny<int>(), It.IsAny<string?>(), It.IsAny<IReadOnlyCollection<string>?>(), It.IsAny<CancellationToken>(), It.IsAny<string?>(), It.IsAny<string?>()))
             .ReturnsAsync((new List<Locations>(), 0));
 
         var allStates = string.Join(",", SeaHaven.Services.Helpers.UsStateCodes.All);
@@ -533,4 +533,97 @@ public class LocationServiceTests
         again.Should().BeFalse();
         ctx.Locations.Should().BeEmpty();
     }
+
+    [Fact]
+    public async Task GetLocationListPagedAsync_NormalizesAndForwardsSortToDataService()
+    {
+        var data = new Mock<ILocationDataService>();
+        string? capturedSort = "sentinel";
+        string? capturedDirection = "sentinel";
+        data.Setup(d => d.GetListPagedAsync(It.IsAny<int>(), It.IsAny<int>(), It.IsAny<string?>(), It.IsAny<IReadOnlyCollection<string>?>(), It.IsAny<CancellationToken>(), It.IsAny<string?>(), It.IsAny<string?>()))
+            .Callback<int, int, string?, IReadOnlyCollection<string>?, CancellationToken, string?, string?>((_, _, _, _, _, sortBy, sortDirection) =>
+            {
+                capturedSort = sortBy;
+                capturedDirection = sortDirection;
+            })
+            .ReturnsAsync((new List<Locations>(), 0));
+
+        await NewServiceWithSpy(data.Object).GetLocationListPagedAsync(1, 10, null, cancellationToken: CancellationToken.None, sortBy: " POC ", sortDirection: " DESC ");
+
+        capturedSort.Should().Be("poc");
+        capturedDirection.Should().Be("desc");
+    }
+
+    [Theory]
+    [InlineData(null, null)]
+    [InlineData("", "  ")]
+    public async Task GetLocationListPagedAsync_BlankOrDefaultSort_PassesNormalizedDefaults(
+        string? sortBy,
+        string? sortDirection)
+    {
+        var data = new Mock<ILocationDataService>();
+        string? capturedSort = "sentinel";
+        string? capturedDirection = "sentinel";
+        data.Setup(d => d.GetListPagedAsync(It.IsAny<int>(), It.IsAny<int>(), It.IsAny<string?>(), It.IsAny<IReadOnlyCollection<string>?>(), It.IsAny<CancellationToken>(), It.IsAny<string?>(), It.IsAny<string?>()))
+            .Callback<int, int, string?, IReadOnlyCollection<string>?, CancellationToken, string?, string?>((_, _, _, _, _, s, d) =>
+            {
+                capturedSort = s;
+                capturedDirection = d;
+            })
+            .ReturnsAsync((new List<Locations>(), 0));
+
+        await NewServiceWithSpy(data.Object).GetLocationListPagedAsync(1, 10, null, cancellationToken: CancellationToken.None, sortBy: sortBy, sortDirection: sortDirection);
+
+        capturedSort.Should().BeNull("a blank sort column must keep the legacy ordering");
+        capturedDirection.Should().Be("asc");
+    }
+
+    [Theory]
+    [InlineData("rating")]
+    [InlineData("password; drop table locations")]
+    public async Task GetLocationListPagedAsync_InvalidSortBy_ThrowsValidationAndNeverQueries(string sortBy)
+    {
+        var data = new Mock<ILocationDataService>();
+
+        var act = () => NewServiceWithSpy(data.Object).GetLocationListPagedAsync(1, 10, null, cancellationToken: CancellationToken.None, sortBy: sortBy);
+
+        (await act.Should().ThrowAsync<FluentValidation.ValidationException>())
+            .Which.Errors.Should().ContainSingle(e =>
+                e.PropertyName == "sortBy"
+                && e.ErrorMessage.Contains("code")
+                && e.ErrorMessage.Contains("poc"));
+        data.Verify(d => d.GetListPagedAsync(It.IsAny<int>(), It.IsAny<int>(), It.IsAny<string?>(), It.IsAny<IReadOnlyCollection<string>?>(), It.IsAny<CancellationToken>(), It.IsAny<string?>(), It.IsAny<string?>()), Times.Never);
+    }
+
+    [Theory]
+    [InlineData("ascending")]
+    [InlineData("DESC; drop table locations")]
+    public async Task GetLocationListPagedAsync_InvalidSortDirection_ThrowsValidationAndNeverQueries(string sortDirection)
+    {
+        var data = new Mock<ILocationDataService>();
+
+        var act = () => NewServiceWithSpy(data.Object).GetLocationListPagedAsync(1, 10, null, cancellationToken: CancellationToken.None, sortBy: "city", sortDirection: sortDirection);
+
+        (await act.Should().ThrowAsync<FluentValidation.ValidationException>())
+            .Which.Errors.Should().ContainSingle(e =>
+                e.PropertyName == "sortDirection"
+                && e.ErrorMessage.Contains("asc")
+                && e.ErrorMessage.Contains("desc"));
+        data.Verify(d => d.GetListPagedAsync(It.IsAny<int>(), It.IsAny<int>(), It.IsAny<string?>(), It.IsAny<IReadOnlyCollection<string>?>(), It.IsAny<CancellationToken>(), It.IsAny<string?>(), It.IsAny<string?>()), Times.Never);
+    }
+
+    [Fact]
+    public async Task GetLocationListPagedAsync_MapsClientAccountNameIntoRows()
+    {
+        using var ctx = NewContext();
+        SeedAccount(ctx, 9, "Acme Co");
+        SeedLocation(ctx, "Alpha Site", "Austin").AccountId = 9;
+        await ctx.SaveChangesAsync();
+
+        var page = await NewService(ctx).GetLocationListPagedAsync(1, 10, null, cancellationToken: CancellationToken.None);
+
+        var row = page.Items.Should().ContainSingle().Subject;
+        row.AccountId.Should().Be(9);
+        row.AccountName.Should().Be("Acme Co");
+    }
 }

Api.SeaHavenIndustries.Tests/LocationSiteContactsTests.cs

@@ -430,7 +430,7 @@ public class LocationSiteContactsTests
     public async Task List_LoadsPageContactsInSingleBatchedRead()
     {
         var data = new Mock<ILocationDataService>();
-        data.Setup(d => d.GetListPagedAsync(It.IsAny<int>(), It.IsAny<int>(), It.IsAny<string?>(), It.IsAny<IReadOnlyCollection<string>?>(), It.IsAny<CancellationToken>()))
+        data.Setup(d => d.GetListPagedAsync(It.IsAny<int>(), It.IsAny<int>(), It.IsAny<string?>(), It.IsAny<IReadOnlyCollection<string>?>(), It.IsAny<CancellationToken>(), It.IsAny<string?>(), It.IsAny<string?>()))
             .ReturnsAsync((new List<Locations>
             {
                 new() { Id = 1, Name = "One" },

Api.SeaHavenIndustries.Tests/ServicesRegistryControllerTests.cs

@@ -0,0 +1,185 @@
+using System.Security.Claims;
+using Api.SeaHavenIndustries.Controllers;
+using Data.SeaHavenIndustries.Enums;
+using FluentAssertions;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using SeaHaven.Services.DTOs;
+using SeaHaven.Services.Exceptions;
+using SeaHaven.Services.Interfaces;
+using Xunit;
+
+namespace Api.SeaHavenIndustries.Tests;
+
+public class ServicesRegistryControllerTests
+{
+    private static ServicesRegistryController NewController(Mock<IServicesRegistryService> service, params string[] roles)
+    {
+        var controller = new ServicesRegistryController(service.Object)
+        {
+            ControllerContext = new ControllerContext
+            {
+                HttpContext = new DefaultHttpContext
+                {
+                    User = new ClaimsPrincipal(new ClaimsIdentity(
+                        roles.Select(r => new Claim(ClaimTypes.Role, r)), "Test"))
+                }
+            }
+        };
+        return controller;
+    }
+
+    private static ServicesRegistryValidationErrorDto? ErrorValue(IActionResult result) =>
+        (result as ObjectResult)?.Value as ServicesRegistryValidationErrorDto;
+
+    [Fact]
+    public async Task GetAll_ReturnsOkWithServices()
+    {
+        var service = new Mock<IServicesRegistryService>();
+        service.Setup(s => s.GetAllAsync(true, WorkOrderType.PM, It.IsAny<CancellationToken>()))
+               .ReturnsAsync(new List<ServiceDto> { new() { Id = 1, Name = "Leak", IsActive = true } });
+
+        var result = await NewController(service, "Admin").GetAll(true, WorkOrderType.PM, CancellationToken.None);
+
+        var ok = result.Should().BeOfType<OkObjectResult>().Subject;
+        (ok.Value as IEnumerable<ServiceDto>).Should().ContainSingle(s => s.Name == "Leak");
+    }
+
+    [Fact]
+    public async Task GetAll_WhenValidationCode_ReturnsBadRequestWithStableCodeAndMessage()
+    {
+        var service = new Mock<IServicesRegistryService>();
+        service.Setup(s => s.GetAllAsync(null, WorkOrderType.Project, It.IsAny<CancellationToken>()))
+               .Throws(new ServicesRegistryValidationException(
+                   "WorkOrderTypeInvalid", "Supported work order types may only include PM, Reactive, or Emergency."));
+
+        var result = await NewController(service, "Admin").GetAll(null, WorkOrderType.Project, CancellationToken.None);
+
+        var bad = result.Should().BeOfType<BadRequestObjectResult>().Subject;
+        ErrorValue(bad)!.Code.Should().Be("WorkOrderTypeInvalid");
+        ErrorValue(bad)!.Message.Should().Be("Supported work order types may only include PM, Reactive, or Emergency.");
+    }
+
+    [Fact]
+    public async Task GetById_WhenMissing_ReturnsNotFoundWithCode()
+    {
+        var service = new Mock<IServicesRegistryService>();
+        service.Setup(s => s.GetByIdAsync(9, It.IsAny<CancellationToken>()))
+               .ReturnsAsync((ServiceDto?)null);
+
+        var result = await NewController(service, "Admin").GetById(9, CancellationToken.None);
+
+        var notFound = result.Should().BeOfType<NotFoundObjectResult>().Subject;
+        ErrorValue(notFound)!.Code.Should().Be("NotFound");
+    }
+
+    [Fact]
+    public async Task Create_PassesCallerAndReturnsCreated()
+    {
+        var service = new Mock<IServicesRegistryService>();
+        service.Setup(s => s.CreateAsync(It.IsAny<ClaimsPrincipal>(), It.IsAny<ServiceInput>(), It.IsAny<CancellationToken>()))
+               .ReturnsAsync(new ServiceDto { Id = 42, Name = "Leak", IsActive = true });
+
+        var result = await NewController(service, "Scheduler").Create(new ServiceInput { Name = "Leak" }, CancellationToken.None);
+
+        var created = result.Should().BeOfType<ObjectResult>().Subject;
+        created.StatusCode.Should().Be(StatusCodes.Status201Created);
+        (created.Value as ServiceDto)!.Id.Should().Be(42);
+        service.Verify(s => s.CreateAsync(
+            It.Is<ClaimsPrincipal>(p => p.IsInRole("Scheduler")),
+            It.Is<ServiceInput>(i => i.Name == "Leak"),
+            It.IsAny<CancellationToken>()), Times.Once);
+    }
+
+    [Fact]
+    public async Task Create_WhenForbidden_Returns403WithStableCode()
+    {
+        var service = new Mock<IServicesRegistryService>();
+        service.Setup(s => s.CreateAsync(It.IsAny<ClaimsPrincipal>(), It.IsAny<ServiceInput>(), It.IsAny<CancellationToken>()))
+               .Throws(new ServicesRegistryValidationException("Forbidden", "Scheduler or Admin role is required."));
+
+        var result = await NewController(service, "User").Create(new ServiceInput { Name = "Leak" }, CancellationToken.None);
+
+        var forbidden = result.Should().BeOfType<ObjectResult>().Subject;
+        forbidden.StatusCode.Should().Be(StatusCodes.Status403Forbidden);
+        ErrorValue(forbidden)!.Code.Should().Be("Forbidden");
+    }
+
+    [Fact]
+    public async Task Create_WhenDuplicateName_Returns400WithStableCode()
+    {
+        var service = new Mock<IServicesRegistryService>();
+        service.Setup(s => s.CreateAsync(It.IsAny<ClaimsPrincipal>(), It.IsAny<ServiceInput>(), It.IsAny<CancellationToken>()))
+               .Throws(new ServicesRegistryValidationException("DuplicateName", "A service with this name already exists."));
+
+        var result = await NewController(service, "Admin").Create(new ServiceInput { Name = "Leak" }, CancellationToken.None);
+
+        var bad = result.Should().BeOfType<BadRequestObjectResult>().Subject;
+        ErrorValue(bad)!.Code.Should().Be("DuplicateName");
+    }
+
+    [Fact]
+    public async Task Update_ReturnsOkWithUpdatedService()
+    {
+        var service = new Mock<IServicesRegistryService>();
+        service.Setup(s => s.UpdateAsync(It.IsAny<ClaimsPrincipal>(), 7, It.IsAny<ServiceInput>(), It.IsAny<CancellationToken>()))
+               .ReturnsAsync(new ServiceDto { Id = 7, Name = "Renamed" });
+
+        var result = await NewController(service, "Admin").Update(7, new ServiceInput { Name = "Renamed" }, CancellationToken.None);
+
+        var ok = result.Should().BeOfType<OkObjectResult>().Subject;
+        (ok.Value as ServiceDto)!.Name.Should().Be("Renamed");
+    }
+
+    [Fact]
+    public async Task Update_WhenNotFound_Returns404WithCode()
+    {
+        var service = new Mock<IServicesRegistryService>();
+        service.Setup(s => s.UpdateAsync(It.IsAny<ClaimsPrincipal>(), 404, It.IsAny<ServiceInput>(), It.IsAny<CancellationToken>()))
+               .Throws(new ServicesRegistryValidationException("NotFound", "Service not found."));
+
+        var result = await NewController(service, "Admin").Update(404, new ServiceInput(), CancellationToken.None);
+
+        var notFound = result.Should().BeOfType<NotFoundObjectResult>().Subject;
+        ErrorValue(notFound)!.Code.Should().Be("NotFound");
+    }
+
+    [Fact]
+    public async Task Deactivate_ReturnsOk()
+    {
+        var service = new Mock<IServicesRegistryService>();
+
+        var result = await NewController(service, "Admin").Deactivate(3, CancellationToken.None);
+
+        result.Should().BeOfType<OkObjectResult>();
+        service.Verify(s => s.DeactivateAsync(
+            It.Is<ClaimsPrincipal>(p => p.IsInRole("Admin")), 3, It.IsAny<CancellationToken>()), Times.Once);
+    }
+
+    [Fact]
+    public async Task Deactivate_WhenForbidden_Returns403WithStableCode()
+    {
+        var service = new Mock<IServicesRegistryService>();
+        service.Setup(s => s.DeactivateAsync(It.IsAny<ClaimsPrincipal>(), 3, It.IsAny<CancellationToken>()))
+               .Throws(new ServicesRegistryValidationException("Forbidden", "Only administrators can deactivate services."));
+
+        var result = await NewController(service, "Scheduler").Deactivate(3, CancellationToken.None);
+
+        var forbidden = result.Should().BeOfType<ObjectResult>().Subject;
+        forbidden.StatusCode.Should().Be(StatusCodes.Status403Forbidden);
+        ErrorValue(forbidden)!.Code.Should().Be("Forbidden");
+    }
+
+    [Fact]
+    public async Task Deactivate_WhenNotFound_Returns404WithCode()
+    {
+        var service = new Mock<IServicesRegistryService>();
+        service.Setup(s => s.DeactivateAsync(It.IsAny<ClaimsPrincipal>(), 404, It.IsAny<CancellationToken>()))
+               .Throws(new ServicesRegistryValidationException("NotFound", "Service not found."));
+
+        var result = await NewController(service, "Admin").Deactivate(404, CancellationToken.None);
+
+        result.Should().BeOfType<NotFoundObjectResult>();
+    }
+}

Api.SeaHavenIndustries.Tests/ServicesRegistryServiceTests.cs

@@ -0,0 +1,396 @@
+using System.Security.Claims;
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+using FluentAssertions;
+using Microsoft.EntityFrameworkCore;
+using SeaHaven.DataServices.Implementation;
+using SeaHaven.Services.DTOs;
+using SeaHaven.Services.Exceptions;
+using SeaHaven.Services.Implementation;
+using Xunit;
+
+namespace Api.SeaHavenIndustries.Tests;
+
+// Global Services registry behavior. The registry has no tenant scope
+// (no AccountId), authorization is enforced at the service boundary, and the
+// only allowed supported work-order types are PM, Reactive, and Emergency.
+public class ServicesRegistryServiceTests
+{
+    private static ApplicationDbContext NewContext()
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
+            .Options;
+        return new ApplicationDbContext(options);
+    }
+
+    private static ServicesRegistryService NewService(ApplicationDbContext ctx) =>
+        new(new ServicesRegistryDataService(ctx));
+
+    private static ClaimsPrincipal Principal(params string[] roles) =>
+        new(new ClaimsIdentity(roles.Select(r => new Claim(ClaimTypes.Role, r)), "Test"));
+
+    private static ClaimsPrincipal Admin() => Principal("Admin");
+    private static ClaimsPrincipal Scheduler() => Principal("Scheduler");
+
+    private static ServiceInput Input(
+        string name = "Leak",
+        string? trade = "Plumbing & Water Systems",
+        string? iconKey = "plumbing-water-systems",
+        bool requiresDoc = false,
+        int? templateId = null,
+        List<WorkOrderType>? types = null) => new()
+        {
+            Name = name,
+            Trade = trade,
+            IconKey = iconKey,
+            RequiresCompletionDocument = requiresDoc,
+            CompletionDocTemplateId = templateId,
+            SupportedWorkOrderTypes = types ?? new List<WorkOrderType>
+            {
+                WorkOrderType.PM, WorkOrderType.Reactive, WorkOrderType.Emergency
+            }
+        };
+
+    private static CompletionDocTemplate Template(string name, bool active = true, bool deleted = false) =>
+        new() { Name = name, ServiceKey = "test", TemplateUrl = "https://example.com/t.pdf", IsActive = active, IsDeleted = deleted };
+
+    [Fact]
+    public async Task Create_PersistsActiveServiceWithNormalizedFieldsAndSupportedTypes()
+    {
+        using var ctx = NewContext();
+
+        var dto = await NewService(ctx).CreateAsync(Scheduler(), Input("  Leak Detection  "), CancellationToken.None);
+
+        dto.Id.Should().BeGreaterThan(0);
+        dto.Name.Should().Be("Leak Detection");
+        dto.Trade.Should().Be("Plumbing & Water Systems");
+        dto.IconKey.Should().Be("plumbing-water-systems");
+        dto.IsActive.Should().BeTrue("new services are always active");
+        dto.CompletionDocTemplate.Should().BeNull();
+        dto.SupportedWorkOrderTypes.Should().BeEquivalentTo(new[] { WorkOrderType.PM, WorkOrderType.Reactive, WorkOrderType.Emergency });
+
+        var row = ctx.Services.Include(s => s.SupportedWorkOrderTypes).Single();
+        row.NormalizedName.Should().Be("leak detection");
+    }
+
+    [Fact]
+    public async Task Create_WhenTypeCategoriesOmitted_DefaultsToSupportedWorkOrderTypes()
+    {
+        using var ctx = NewContext();
+
+        var input = Input(types: null);
+        input.SupportedWorkOrderTypes = null;
+
+        var dto = await NewService(ctx).CreateAsync(Admin(), input, CancellationToken.None);
+
+        dto.SupportedWorkOrderTypes.Should().BeEquivalentTo(new[]
+        {
+            WorkOrderType.PM, WorkOrderType.Reactive, WorkOrderType.Emergency
+        });
+    }
+
+    [Theory]
+    [InlineData(null)]
+    [InlineData("")]
+    [InlineData("   ")]
+    public async Task Create_WhenNameBlank_ThrowsNameRequired(string? name)
+    {
+        using var ctx = NewContext();
+        var act = () => NewService(ctx).CreateAsync(Admin(), Input(name: name!), CancellationToken.None);
+        var ex = (await act.Should().ThrowAsync<ServicesRegistryValidationException>()).Subject.Single();
+        ex.Code.Should().Be("NameRequired");
+    }
+
+    [Fact]
+    public async Task Create_WhenTradeNotCanonical_ThrowsTradeInvalid()
+    {
+        using var ctx = NewContext();
+        var act = () => NewService(ctx).CreateAsync(Admin(), Input(trade: "Roofing"), CancellationToken.None);
+        (await act.Should().ThrowAsync<ServicesRegistryValidationException>()).Which.Code.Should().Be("TradeInvalid");
+    }
+
+    [Theory]
+    [InlineData("  hvac  ")]
+    [InlineData("HVAC")]
+    [InlineData("hvac")]
+    public async Task Create_AcceptsCanonicalTradeInAnyCasingOrPadding(string trade)
+    {
+        using var ctx = NewContext();
+        var dto = await NewService(ctx).CreateAsync(Admin(), Input(name: "Cooling", trade: trade, iconKey: "hvac"), CancellationToken.None);
+        dto.Trade.Should().Be("HVAC");
+    }
+
+    [Theory]
+    [InlineData(null)]
+    [InlineData("")]
+    [InlineData("   ")]
+    public async Task Create_WhenIconKeyBlank_ThrowsIconKeyInvalid(string? iconKey)
+    {
+        using var ctx = NewContext();
+        var act = () => NewService(ctx).CreateAsync(Admin(), Input(iconKey: iconKey!), CancellationToken.None);
+        (await act.Should().ThrowAsync<ServicesRegistryValidationException>()).Which.Code.Should().Be("IconKeyInvalid");
+    }
+
+    [Fact]
+    public async Task Create_WhenNormalizedNameExists_ThrowsDuplicateName_RegardlessOfCasing()
+    {
+        using var ctx = NewContext();
+        var service = NewService(ctx);
+        await service.CreateAsync(Admin(), Input("Leak"), CancellationToken.None);
+
+        var act = () => service.CreateAsync(Admin(), Input("  LEAK  "), CancellationToken.None);
+        (await act.Should().ThrowAsync<ServicesRegistryValidationException>()).Which.Code.Should().Be("DuplicateName");
+    }
+
+    [Fact]
+    public async Task Registry_IsGlobal_SingleScopeWithoutAccountOrTenantFilter()
+    {
+        using var ctx = NewContext();
+        var service = NewService(ctx);
+        // Distinct actors with different role sets still share one global registry.
+        var first = await service.CreateAsync(Admin(), Input("Leak"), CancellationToken.None);
+        var act = () => service.CreateAsync(Scheduler(), Input("Leak"), CancellationToken.None);
+        (await act.Should().ThrowAsync<ServicesRegistryValidationException>()).Which.Code.Should().Be("DuplicateName");
+
+        var all = await service.GetAllAsync(null, null, CancellationToken.None);
+        all.Should().ContainSingle(s => s.Id == first.Id);
+        typeof(Service).GetProperty("AccountId").Should().BeNull("tenant scope is global, matching DropdownOptions");
+    }
+
+    [Fact]
+    public async Task Create_WhenCallerLacksSchedulerAndAdminRole_ThrowsForbidden()
+    {
+        using var ctx = NewContext();
+        var act = () => NewService(ctx).CreateAsync(Principal("User"), Input(), CancellationToken.None);
+        (await act.Should().ThrowAsync<ServicesRegistryValidationException>()).Which.Code.Should().Be("Forbidden");
+    }
+
+    [Fact]
+    public async Task Create_WhenCallerUnauthenticated_ThrowsForbidden()
+    {
+        using var ctx = NewContext();
+        var act = () => NewService(ctx).CreateAsync(Principal(), Input(), CancellationToken.None);
+        (await act.Should().ThrowAsync<ServicesRegistryValidationException>()).Which.Code.Should().Be("Forbidden");
+    }
+
+    [Fact]
+    public async Task Create_WhenTemplateMissing_Inactive_OrDeleted_ThrowsTemplateInvalid()
+    {
+        using var ctx = NewContext();
+
+        (await new Func<Task<ServiceDto>>(() => NewService(ctx).CreateAsync(
+                Admin(), Input(requiresDoc: true, templateId: 999), CancellationToken.None))
+            .Should().ThrowAsync<ServicesRegistryValidationException>()).Which.Code.Should().Be("TemplateInvalid");
+
+        ctx.CompletionDocTemplates.Add(Template("Inactive", active: false));
+        ctx.CompletionDocTemplates.Add(Template("Deleted", deleted: true));
+        ctx.SaveChanges();
+
+        (await new Func<Task<ServiceDto>>(() => NewService(ctx).CreateAsync(
+                Admin(), Input(requiresDoc: true, templateId: ctx.CompletionDocTemplates.Local.First(t => t.Name == "Inactive").Id), CancellationToken.None))
+            .Should().ThrowAsync<ServicesRegistryValidationException>()).Which.Code.Should().Be("TemplateInvalid");
+
+        (await new Func<Task<ServiceDto>>(() => NewService(ctx).CreateAsync(
+                Admin(), Input(requiresDoc: true, templateId: ctx.CompletionDocTemplates.Local.First(t => t.Name == "Deleted").Id), CancellationToken.None))
+            .Should().ThrowAsync<ServicesRegistryValidationException>()).Which.Code.Should().Be("TemplateInvalid");
+    }
+
+    [Fact]
+    public async Task Create_WithActiveTemplate_ProjectsLinkedTemplateSummary()
+    {
+        using var ctx = NewContext();
+        var template = Template("Completion Packet");
+        ctx.CompletionDocTemplates.Add(template);
+        ctx.SaveChanges();
+
+        var dto = await NewService(ctx).CreateAsync(
+            Admin(), Input(requiresDoc: true, templateId: template.Id), CancellationToken.None);
+
+        dto.RequiresCompletionDocument.Should().BeTrue();
+        dto.CompletionDocTemplate.Should().NotBeNull();
+        dto.CompletionDocTemplate!.Id.Should().Be(template.Id);
+        dto.CompletionDocTemplate.Name.Should().Be("Completion Packet");
+    }
+
+    [Fact]
+    public async Task Create_WhenCompletionToggleOff_IgnoresTemplateLink()
+    {
+        using var ctx = NewContext();
+        var template = Template("Completion Packet");
+        ctx.CompletionDocTemplates.Add(template);
+        ctx.SaveChanges();
+
+        var dto = await NewService(ctx).CreateAsync(
+            Admin(), Input(requiresDoc: false, templateId: template.Id), CancellationToken.None);
+
+        dto.RequiresCompletionDocument.Should().BeFalse();
+        dto.CompletionDocTemplate.Should().BeNull();
+        ctx.Services.Single().CompletionDocTemplateId.Should().BeNull();
+    }
+
+    [Theory]
+    [InlineData(WorkOrderType.PO)]
+    [InlineData(WorkOrderType.Project)]
+    [InlineData(WorkOrderType.Inspection)]
+    [InlineData(WorkOrderType.AddOn)]
+    [InlineData(WorkOrderType.Other)]
+    public async Task Create_WhenUnsupportedWorkOrderType_ThrowsWorkOrderTypeInvalid(WorkOrderType unsupported)
+    {
+        using var ctx = NewContext();
+        var input = Input(types: new List<WorkOrderType> { WorkOrderType.PM, unsupported });
+        var act = () => NewService(ctx).CreateAsync(Admin(), input, CancellationToken.None);
+        (await act.Should().ThrowAsync<ServicesRegistryValidationException>()).Which.Code.Should().Be("WorkOrderTypeInvalid");
+    }
+
+    [Fact]
+    public async Task Update_RewritesFieldsButPreservesActiveState()
+    {
+        using var ctx = NewContext();
+        var service = NewService(ctx);
+        var created = await service.CreateAsync(Admin(), Input("Leak"), CancellationToken.None);
+        await service.DeactivateAsync(Admin(), created.Id, CancellationToken.None);
+
+        var updated = await service.UpdateAsync(
+            Admin(), created.Id, Input("Leak Repair", trade: "HVAC", iconKey: "hvac"), CancellationToken.None);
+
+        updated.Name.Should().Be("Leak Repair");
+        updated.Trade.Should().Be("HVAC");
+        updated.IconKey.Should().Be("hvac");
+        updated.IsActive.Should().BeFalse("update preserves the persisted active state");
+    }
+
+    [Fact]
+    public async Task Update_WhenAdminRequestsActiveState_ReactivatesService()
+    {
+        using var ctx = NewContext();
+        var service = NewService(ctx);
+        var created = await service.CreateAsync(Admin(), Input("Inactive service"), CancellationToken.None);
+        await service.DeactivateAsync(Admin(), created.Id, CancellationToken.None);
+
+        var input = Input("Inactive service");
+        input.IsActive = true;
+        var updated = await service.UpdateAsync(Admin(), created.Id, input, CancellationToken.None);
+
+        updated.IsActive.Should().BeTrue();
+        ctx.Services.Single().IsActive.Should().BeTrue();
+    }
+
+    [Fact]
+    public async Task Update_WhenSchedulerRequestsActiveState_ThrowsForbidden()
+    {
+        using var ctx = NewContext();
+        var service = NewService(ctx);
+        var created = await service.CreateAsync(Admin(), Input("Inactive service"), CancellationToken.None);
+        await service.DeactivateAsync(Admin(), created.Id, CancellationToken.None);
+
+        var input = Input("Inactive service");
+        input.IsActive = true;
+        var act = () => service.UpdateAsync(Scheduler(), created.Id, input, CancellationToken.None);
+
+        (await act.Should().ThrowAsync<ServicesRegistryValidationException>()).Which.Code.Should().Be("Forbidden");
+        ctx.Services.Single().IsActive.Should().BeFalse();
+    }
+
+    [Fact]
+    public async Task Update_WhenNotFound_ThrowsNotFound()
+    {
+        using var ctx = NewContext();
+        var act = () => NewService(ctx).UpdateAsync(Admin(), 404, Input(), CancellationToken.None);
+        (await act.Should().ThrowAsync<ServicesRegistryValidationException>()).Which.Code.Should().Be("NotFound");
+    }
+
+    [Fact]
+    public async Task Update_WhenDuplicateNameElsewhere_ThrowsDuplicateName()
+    {
+        using var ctx = NewContext();
+        var service = NewService(ctx);
+        var first = await service.CreateAsync(Admin(), Input("Leak"), CancellationToken.None);
+        await service.CreateAsync(Admin(), Input("Clog"), CancellationToken.None);
+
+        var act = () => service.UpdateAsync(Admin(), first.Id, Input("clog"), CancellationToken.None);
+        (await act.Should().ThrowAsync<ServicesRegistryValidationException>()).Which.Code.Should().Be("DuplicateName");
+    }
+
+    [Fact]
+    public async Task Update_WhenCallerLacksRole_ThrowsForbidden_BeforeAnyMutation()
+    {
+        using var ctx = NewContext();
+        var service = NewService(ctx);
+        var created = await service.CreateAsync(Admin(), Input("Leak"), CancellationToken.None);
+
+        var act = () => service.UpdateAsync(Principal("User"), created.Id, Input("Changed"), CancellationToken.None);
+        (await act.Should().ThrowAsync<ServicesRegistryValidationException>()).Which.Code.Should().Be("Forbidden");
+        ctx.Services.Single().Name.Should().Be("Leak");
+    }
+
+    [Fact]
+    public async Task Deactivate_SoftStateChangeOnly_PreservesRow()
+    {
+        using var ctx = NewContext();
+        var service = NewService(ctx);
+        var created = await service.CreateAsync(Admin(), Input("Leak"), CancellationToken.None);
+
+        await service.DeactivateAsync(Admin(), created.Id, CancellationToken.None);
+
+        ctx.Services.Should().HaveCount(1, "deactivation never hard deletes");
+        var byId = await service.GetByIdAsync(created.Id, CancellationToken.None);
+        byId.Should().NotBeNull();
+        byId!.IsActive.Should().BeFalse();
+    }
+
+    [Fact]
+    public async Task Deactivate_WhenScheduler_ThrowsForbidden()
+    {
+        using var ctx = NewContext();
+        var service = NewService(ctx);
+        var created = await service.CreateAsync(Admin(), Input("Leak"), CancellationToken.None);
+
+        var act = () => service.DeactivateAsync(Scheduler(), created.Id, CancellationToken.None);
+        (await act.Should().ThrowAsync<ServicesRegistryValidationException>()).Which.Code.Should().Be("Forbidden");
+        ctx.Services.Single().IsActive.Should().BeTrue();
+    }
+
+    [Fact]
+    public async Task Deactivate_WhenNotFound_ThrowsNotFound()
+    {
+        using var ctx = NewContext();
+        var act = () => NewService(ctx).DeactivateAsync(Admin(), 404, CancellationToken.None);
+        (await act.Should().ThrowAsync<ServicesRegistryValidationException>()).Which.Code.Should().Be("NotFound");
+    }
+
+    [Fact]
+    public async Task GetAll_FiltersByActiveStateAndWorkOrderType()
+    {
+        using var ctx = NewContext();
+        var service = NewService(ctx);
+        var pm = await service.CreateAsync(Admin(), Input("PM Service", types: new List<WorkOrderType> { WorkOrderType.PM }), CancellationToken.None);
+        var reactive = await service.CreateAsync(Admin(), Input(name: "Reactive Service", trade: "HVAC", iconKey: "hvac", types: new List<WorkOrderType> { WorkOrderType.Reactive }), CancellationToken.None);
+        await service.DeactivateAsync(Admin(), reactive.Id, CancellationToken.None);
+
+        (await service.GetAllAsync(true, null, CancellationToken.None)).Select(s => s.Id)
+            .Should().BeEquivalentTo(new[] { pm.Id });
+        (await service.GetAllAsync(false, null, CancellationToken.None)).Select(s => s.Id)
+            .Should().BeEquivalentTo(new[] { reactive.Id });
+
+        (await service.GetAllAsync(null, WorkOrderType.PM, CancellationToken.None)).Select(s => s.Id)
+            .Should().BeEquivalentTo(new[] { pm.Id });
+        (await service.GetAllAsync(null, WorkOrderType.Emergency, CancellationToken.None))
+            .Should().BeEmpty();
+    }
+
+    [Fact]
+    public async Task GetAll_WhenWorkOrderTypeFilterUnsupported_ThrowsWorkOrderTypeInvalid()
+    {
+        using var ctx = NewContext();
+        var act = () => NewService(ctx).GetAllAsync(null, WorkOrderType.Project, CancellationToken.None);
+        (await act.Should().ThrowAsync<ServicesRegistryValidationException>()).Which.Code.Should().Be("WorkOrderTypeInvalid");
+    }
+
+    [Fact]
+    public async Task GetById_WhenMissing_ReturnsNull()
+    {
+        using var ctx = NewContext();
+        (await NewService(ctx).GetByIdAsync(99, CancellationToken.None)).Should().BeNull();
+    }
+}

Api.SeaHavenIndustries.Tests/TeamMemberServiceTests.cs

@@ -216,6 +216,57 @@ public sealed class TeamMemberServiceTests
         overrides.Verify(data => data.SetOverridesAsync(user.Id, It.Is<IReadOnlyDictionary<string, UserPermissionState>>(value => value["createSites"] == UserPermissionState.Deny), It.IsAny<CancellationToken>()), Times.Once);
     }
 
+    [Fact]
+    public async Task Update_SavesUnchangedNameWithoutDuplicatingRoleLikeLastName()
+    {
+        var service = NewService(
+            out var userManager,
+            out var roleManager,
+            out var areas,
+            out _,
+            out var userData,
+            out var permissions);
+        var user = new ApplicationUser
+        {
+            Id = "admin",
+            FirstName = "Legacy",
+            LastName = "Manager",
+            Email = "legacy@example.com",
+            Color = "#F59E0B",
+            UniqueName = "Active"
+        };
+        userManager.Setup(manager => manager.FindByIdAsync(user.Id)).ReturnsAsync(user);
+        userManager.Setup(manager => manager.GetRolesAsync(user)).ReturnsAsync(new List<string> { "Admin" });
+        userManager.Setup(manager => manager.FindByEmailAsync(user.Email!)).ReturnsAsync(user);
+        roleManager.Setup(manager => manager.RoleExistsAsync("Admin")).ReturnsAsync(true);
+        areas.Setup(data => data.GetForUserAsync(user.Id, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(Array.Empty<string>());
+        permissions.Setup(data => data.GetProfileAsync(user.Id, It.IsAny<ClaimsPrincipal>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync(TeamPermissionResult<TeamPermissionProfileDTO>.Success(new TeamPermissionProfileDTO
+            {
+                UserId = user.Id,
+                Permissions = Array.Empty<TeamPermissionValueDTO>()
+            }));
+
+        var result = await service.UpdateAsync(
+            user.Id,
+            new UpdateTeamMemberRequestDTO
+            {
+                Name = "Legacy Manager",
+                Role = "Admin",
+                Color = "#F59E0B",
+                Email = user.Email
+            },
+            Admin(),
+            CancellationToken.None);
+
+        result.Success.Should().BeTrue();
+        user.FirstName.Should().Be("Legacy");
+        user.LastName.Should().Be("Manager");
+        result.Member!.Name.Should().Be("Legacy Manager");
+        userData.Verify(data => data.UpdateUserAsync(user, It.IsAny<CancellationToken>()), Times.Once);
+    }
+
     [Fact]
     public async Task Update_LeavesOmittedOverridesUnchanged()
     {

Api.SeaHavenIndustries/Controllers/DashboardController.cs

@@ -30,6 +30,9 @@ namespace Api.SeaHavenIndustries.Controllers
                 open = stats.Open,
                 notDispatched = stats.NotDispatched,
                 completed = stats.Completed,
+                scheduledTomorrow = stats.ScheduledTomorrow,
+                pendingUplifts = stats.PendingUplifts,
+                avetaPending = stats.AvetaPending,
                 breakdown = stats.Breakdown,
                 dueCount = stats.DueCount,
                 completedDueCount = stats.CompletedDueCount,

Api.SeaHavenIndustries/Controllers/LocationController.cs

@@ -36,11 +36,11 @@ namespace Api.SeaHavenIndustries.Controllers
         }
 
         [HttpGet("GetLocationList")]
-        public async Task<IActionResult> GetLocationList(string? search = "", int page = 1, int pageSize = 10, string? states = null, CancellationToken cancellationToken = default)
+        public async Task<IActionResult> GetLocationList(string? search = "", int page = 1, int pageSize = 10, string? states = null, string? sortBy = null, string? sortDirection = null, CancellationToken cancellationToken = default)
         {
             try
             {
-                var pagedResult = await _locationService.GetLocationListPagedAsync(page, pageSize, search, states, cancellationToken);
+                var pagedResult = await _locationService.GetLocationListPagedAsync(page, pageSize, search, states, cancellationToken, sortBy, sortDirection);
 
                 var data = pagedResult.Items.Select(l => new
                 {
@@ -58,6 +58,8 @@ namespace Api.SeaHavenIndustries.Controllers
                     ContactEmail = l.Email,
                     Status = l.Status,
                     AccountId = l.AccountId,
+                    ClientName = l.AccountName,
+                    AccountName = l.AccountName,
                     Contacts = l.Contacts?.Select(c => new { c.Id, c.Name, c.Phone }).ToList()
                 });
 

Api.SeaHavenIndustries/Controllers/ServicesRegistryController.cs

@@ -0,0 +1,110 @@
+using Data.SeaHavenIndustries.Enums;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using SeaHaven.Services.DTOs;
+using SeaHaven.Services.Exceptions;
+using SeaHaven.Services.Interfaces;
+
+namespace Api.SeaHavenIndustries.Controllers
+{
+    [Authorize]
+    [ApiController]
+    [Route("api/services")]
+    public class ServicesRegistryController : Controller
+    {
+        private readonly IServicesRegistryService _servicesRegistryService;
+
+        public ServicesRegistryController(IServicesRegistryService servicesRegistryService)
+        {
+            _servicesRegistryService = servicesRegistryService;
+        }
+
+        [HttpGet]
+        public async Task<IActionResult> GetAll([FromQuery] bool? isActive, [FromQuery] WorkOrderType? workOrderType, CancellationToken cancellationToken)
+        {
+            try
+            {
+                var services = await _servicesRegistryService.GetAllAsync(isActive, workOrderType, cancellationToken);
+                return Ok(services);
+            }
+            catch (ServicesRegistryValidationException ex)
+            {
+                return BadRequest(new ServicesRegistryValidationErrorDto { Code = ex.Code, Message = ex.Message });
+            }
+        }
+
+        [HttpGet("{id}")]
+        public async Task<IActionResult> GetById(int id, CancellationToken cancellationToken)
+        {
+            var service = await _servicesRegistryService.GetByIdAsync(id, cancellationToken);
+            if (service == null)
+                return NotFound(new ServicesRegistryValidationErrorDto { Code = "NotFound", Message = "Service not found." });
+
+            return Ok(service);
+        }
+
+        [HttpPost]
+        public async Task<IActionResult> Create([FromBody] ServiceInput input, CancellationToken cancellationToken)
+        {
+            try
+            {
+                var created = await _servicesRegistryService.CreateAsync(User, input, cancellationToken);
+                return StatusCode(StatusCodes.Status201Created, created);
+            }
+            catch (ServicesRegistryValidationException ex) when (ex.Code == "Forbidden")
+            {
+                return MapForbidden(ex);
+            }
+            catch (ServicesRegistryValidationException ex)
+            {
+                return BadRequest(new ServicesRegistryValidationErrorDto { Code = ex.Code, Message = ex.Message });
+            }
+        }
+
+        [HttpPut("{id}")]
+        public async Task<IActionResult> Update(int id, [FromBody] ServiceInput input, CancellationToken cancellationToken)
+        {
+            try
+            {
+                var updated = await _servicesRegistryService.UpdateAsync(User, id, input, cancellationToken);
+                return Ok(updated);
+            }
+            catch (ServicesRegistryValidationException ex) when (ex.Code == "NotFound")
+            {
+                return NotFound(new ServicesRegistryValidationErrorDto { Code = ex.Code, Message = ex.Message });
+            }
+            catch (ServicesRegistryValidationException ex) when (ex.Code == "Forbidden")
+            {
+                return MapForbidden(ex);
+            }
+            catch (ServicesRegistryValidationException ex)
+            {
+                return BadRequest(new ServicesRegistryValidationErrorDto { Code = ex.Code, Message = ex.Message });
+            }
+        }
+
+        [HttpPost("{id}/deactivate")]
+        public async Task<IActionResult> Deactivate(int id, CancellationToken cancellationToken)
+        {
+            try
+            {
+                await _servicesRegistryService.DeactivateAsync(User, id, cancellationToken);
+                return Ok(new { message = "Service deactivated" });
+            }
+            catch (ServicesRegistryValidationException ex) when (ex.Code == "NotFound")
+            {
+                return NotFound(new ServicesRegistryValidationErrorDto { Code = ex.Code, Message = ex.Message });
+            }
+            catch (ServicesRegistryValidationException ex) when (ex.Code == "Forbidden")
+            {
+                return MapForbidden(ex);
+            }
+        }
+
+        private IActionResult MapForbidden(ServicesRegistryValidationException ex)
+        {
+            return StatusCode(StatusCodes.Status403Forbidden,
+                new ServicesRegistryValidationErrorDto { Code = ex.Code, Message = ex.Message });
+        }
+    }
+}

Data.SeaHavenIndustries/Auth/ApplicationDbContext.cs

@@ -80,6 +80,12 @@ namespace Data.SeaHavenIndustries
                 .HasIndex(w => w.InternalWONumber)
                 .HasFilter("[istemplate] = 0");
 
+            builder.Entity<WorkOrder>()
+                .HasOne(w => w.ServiceDefinition)
+                .WithMany()
+                .HasForeignKey(w => w.ServiceId)
+                .OnDelete(DeleteBehavior.Restrict);
+
             builder.Entity<WorkOrder>()
                 .HasIndex(w => new { w.LifecycleStatus, w.ScheduledDate })
                 .HasFilter("[istemplate] = 0");
@@ -213,6 +219,53 @@ namespace Data.SeaHavenIndustries
                 .HasIndex(t => t.NormalizedName)
                 .IsUnique();
 
+            // Bounded lengths keep the unique NormalizedName key SQL
+            // Server-indexable (nvarchar(max) is not).
+            builder.Entity<Service>()
+                .Property(s => s.Name)
+                .HasMaxLength(200);
+
+            builder.Entity<Service>()
+                .Property(s => s.NormalizedName)
+                .HasMaxLength(200);
+
+            builder.Entity<Service>()
+                .HasIndex(s => s.NormalizedName)
+                .IsUnique();
+
+            builder.Entity<Service>()
+                .Property(s => s.Trade)
+                .HasMaxLength(64);
+
+            builder.Entity<Service>()
+                .HasIndex(s => s.Trade);
+
+            builder.Entity<Service>()
+                .Property(s => s.IconKey)
+                .HasMaxLength(64);
+
+            builder.Entity<Service>()
+                .HasIndex(s => s.IsActive);
+
+            builder.Entity<Service>()
+                .HasOne(s => s.CompletionDocTemplate)
+                .WithMany()
+                .HasForeignKey(s => s.CompletionDocTemplateId)
+                .OnDelete(DeleteBehavior.Restrict);
+
+            builder.Entity<Service>()
+                .HasIndex(s => s.CompletionDocTemplateId);
+
+            builder.Entity<ServiceWorkOrderType>()
+                .HasIndex(t => new { t.ServiceId, t.WorkOrderType })
+                .IsUnique();
+
+            builder.Entity<ServiceWorkOrderType>()
+                .HasOne(t => t.Service)
+                .WithMany(s => s.SupportedWorkOrderTypes)
+                .HasForeignKey(t => t.ServiceId)
+                .OnDelete(DeleteBehavior.Restrict);
+
             // SH-278 Area catalogue: bounded names so the unique key is indexable.
             builder.Entity<Area>()
                 .Property(a => a.Name)
@@ -313,6 +366,8 @@ namespace Data.SeaHavenIndustries
         public DbSet<DispatchUpliftRequest> DispatchUpliftRequests { get; set; }
         public DbSet<TaskListTemplate> TaskListTemplates { get; set; }
         public DbSet<TaskListTemplateItem> TaskListTemplateItems { get; set; }
+        public DbSet<Service> Services { get; set; }
+        public DbSet<ServiceWorkOrderType> ServiceWorkOrderTypes { get; set; }
 
         // New DbSets for added entities
         public DbSet<Accounts> Accounts { get; set; }

Data.SeaHavenIndustries/Migrations/20260916185443_SH303_ServicesRegistry.cs

@@ -0,0 +1,162 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Data.SeaHavenIndustries.Migrations
+{
+    /// <inheritdoc />
+    public partial class SH303_ServicesRegistry : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "Services",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    Name = table.Column<string>(type: "nvarchar(200)", maxLength: 200, nullable: false),
+                    NormalizedName = table.Column<string>(type: "nvarchar(200)", maxLength: 200, nullable: false),
+                    Trade = table.Column<string>(type: "nvarchar(64)", maxLength: 64, nullable: false),
+                    IconKey = table.Column<string>(type: "nvarchar(64)", maxLength: 64, nullable: false),
+                    RequiresCompletionDocument = table.Column<bool>(type: "bit", nullable: false),
+                    CompletionDocTemplateId = table.Column<int>(type: "int", nullable: true),
+                    IsActive = table.Column<bool>(type: "bit", nullable: false),
+                    IsDeleted = table.Column<bool>(type: "bit", nullable: true),
+                    createdby = table.Column<string>(type: "nvarchar(max)", nullable: true),
+                    DeleterUserId = table.Column<string>(type: "nvarchar(max)", nullable: true),
+                    DeletionTime = table.Column<DateTime>(type: "datetime2", nullable: true),
+                    CreatedDate = table.Column<DateTime>(type: "datetime2", nullable: true),
+                    LastModificationTime = table.Column<DateTime>(type: "datetime2", nullable: true),
+                    LastModifierUserId = table.Column<int>(type: "int", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Services", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Services_CompletionDocTemplates_CompletionDocTemplateId",
+                        column: x => x.CompletionDocTemplateId,
+                        principalTable: "CompletionDocTemplates",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "ServiceWorkOrderTypes",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    ServiceId = table.Column<int>(type: "int", nullable: false),
+                    WorkOrderType = table.Column<int>(type: "int", nullable: false),
+                    IsDeleted = table.Column<bool>(type: "bit", nullable: true),
+                    createdby = table.Column<string>(type: "nvarchar(max)", nullable: true),
+                    DeleterUserId = table.Column<string>(type: "nvarchar(max)", nullable: true),
+                    DeletionTime = table.Column<DateTime>(type: "datetime2", nullable: true),
+                    CreatedDate = table.Column<DateTime>(type: "datetime2", nullable: true),
+                    LastModificationTime = table.Column<DateTime>(type: "datetime2", nullable: true),
+                    LastModifierUserId = table.Column<int>(type: "int", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_ServiceWorkOrderTypes", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_ServiceWorkOrderTypes_Services_ServiceId",
+                        column: x => x.ServiceId,
+                        principalTable: "Services",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Services_CompletionDocTemplateId",
+                table: "Services",
+                column: "CompletionDocTemplateId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Services_IsActive",
+                table: "Services",
+                column: "IsActive");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Services_NormalizedName",
+                table: "Services",
+                column: "NormalizedName",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Services_Trade",
+                table: "Services",
+                column: "Trade");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ServiceWorkOrderTypes_ServiceId_WorkOrderType",
+                table: "ServiceWorkOrderTypes",
+                columns: new[] { "ServiceId", "WorkOrderType" },
+                unique: true);
+
+            // Additive seed: one active service per active Problem dropdown
+            // value already stored in the database (never the prototype's demo
+            // leaves). Idempotent via NormalizedName NOT EXISTS; dropdown rows are
+            // only read, never altered. Repeated source values collapse onto a
+            // deterministic MIN(Value) representative per normalized key.
+            migrationBuilder.Sql(
+                """
+                INSERT INTO [Services] ([Name], [NormalizedName], [Trade], [IconKey], [RequiresCompletionDocument], [CompletionDocTemplateId], [IsActive], [IsDeleted], [createdby])
+                SELECT seeded.[Name], seeded.[NormalizedName], seeded.[Trade],
+                       CASE seeded.[Trade]
+                           WHEN N'Plumbing & Water Systems' THEN N'plumbing-water-systems'
+                           WHEN N'Electrical' THEN N'electrical'
+                           WHEN N'HVAC' THEN N'hvac'
+                           WHEN N'Fire & Life Safety' THEN N'fire-life-safety'
+                           ELSE N'general-building-handyman'
+                       END,
+                       0, NULL, 1, 0, N'sh303-migration'
+                FROM (
+                    SELECT agg.[Name], agg.[NormalizedName],
+                           CASE
+                               WHEN agg.[Name] IN (N'Leak', N'Clogged') THEN N'Plumbing & Water Systems'
+                               WHEN agg.[Name] = N'No Power' THEN N'Electrical'
+                               WHEN agg.[Name] IN (N'Not Cooling', N'Not Heating') THEN N'HVAC'
+                               WHEN agg.[Name] = N'Alarm Fault' THEN N'Fire & Life Safety'
+                               ELSE N'General Building & Handyman'
+                           END AS [Trade]
+                    FROM (
+                        SELECT MIN(src.[Value]) AS [Name],
+                               LOWER(LTRIM(RTRIM(src.[Value]))) AS [NormalizedName]
+                        FROM [DropdownOptions] src
+                        WHERE src.[Category] = N'Problem'
+                          AND src.[IsActive] = 1
+                        GROUP BY LOWER(LTRIM(RTRIM(src.[Value])))
+                    ) agg
+                ) seeded
+                WHERE NOT EXISTS (
+                    SELECT 1 FROM [Services] s WHERE s.[NormalizedName] = seeded.[NormalizedName]
+                );
+
+                INSERT INTO [ServiceWorkOrderTypes] ([ServiceId], [WorkOrderType], [IsDeleted])
+                SELECT s.[Id], types.[WorkOrderType], 0
+                FROM [Services] s
+                CROSS JOIN (VALUES (2), (6), (3)) AS types([WorkOrderType])
+                WHERE s.[createdby] = N'sh303-migration'
+                  AND NOT EXISTS (
+                      SELECT 1 FROM [ServiceWorkOrderTypes] x
+                      WHERE x.[ServiceId] = s.[Id]
+                        AND x.[WorkOrderType] = types.[WorkOrderType]
+                  );
+                """);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "ServiceWorkOrderTypes");
+
+            migrationBuilder.DropTable(
+                name: "Services");
+        }
+    }
+}

Data.SeaHavenIndustries/Migrations/20260916204606_SH187_WorkOrderServiceLink.cs

@@ -0,0 +1,73 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Data.SeaHavenIndustries.Migrations
+{
+    /// <inheritdoc />
+    public partial class SH187_WorkOrderServiceLink : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "ServiceId",
+                table: "workOrders",
+                type: "int",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "ServiceNameSnapshot",
+                table: "workOrders",
+                type: "nvarchar(200)",
+                maxLength: 200,
+                nullable: true);
+
+            migrationBuilder.Sql(
+                """
+                UPDATE w
+                SET
+                    w.[ServiceNameSnapshot] = LEFT(COALESCE(NULLIF(LTRIM(RTRIM(w.[Trade])), N''), NULLIF(LTRIM(RTRIM(w.[Problem])), N'')), 200),
+                    w.[ServiceId] = s.[Id]
+                FROM [workOrders] w
+                LEFT JOIN [Services] s
+                    ON (s.[IsDeleted] <> 1 OR s.[IsDeleted] IS NULL)
+                    AND s.[NormalizedName] = LOWER(LTRIM(RTRIM(COALESCE(NULLIF(LTRIM(RTRIM(w.[Trade])), N''), NULLIF(LTRIM(RTRIM(w.[Problem])), N'')))))
+                WHERE w.[ServiceNameSnapshot] IS NULL;
+                """);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_workOrders_ServiceId",
+                table: "workOrders",
+                column: "ServiceId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_workOrders_Services_ServiceId",
+                table: "workOrders",
+                column: "ServiceId",
+                principalTable: "Services",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Restrict);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_workOrders_Services_ServiceId",
+                table: "workOrders");
+
+            migrationBuilder.DropIndex(
+                name: "IX_workOrders_ServiceId",
+                table: "workOrders");
+
+            migrationBuilder.DropColumn(
+                name: "ServiceId",
+                table: "workOrders");
+
+            migrationBuilder.DropColumn(
+                name: "ServiceNameSnapshot",
+                table: "workOrders");
+        }
+    }
+}

Data.SeaHavenIndustries/Migrations/ApplicationDbContextModelSnapshot.cs

@@ -1805,6 +1805,121 @@ namespace Data.SeaHavenIndustries.Migrations
                     b.ToTable("Regions");
                 });
 
+            modelBuilder.Entity("Data.SeaHavenIndustries.Service", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("CompletionDocTemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("IconKey")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("nvarchar(64)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("NormalizedName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<bool>("RequiresCompletionDocument")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Trade")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("nvarchar(64)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CompletionDocTemplateId");
+
+                    b.HasIndex("IsActive");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique();
+
+                    b.HasIndex("Trade");
+
+                    b.ToTable("Services");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.ServiceWorkOrderType", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ServiceId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WorkOrderType")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ServiceId", "WorkOrderType")
+                        .IsUnique();
+
+                    b.ToTable("ServiceWorkOrderTypes");
+                });
+
             modelBuilder.Entity("Data.SeaHavenIndustries.SitePreferredVendor", b =>
                 {
                     b.Property<int>("Id")
@@ -2681,6 +2796,13 @@ namespace Data.SeaHavenIndustries.Migrations
                         .HasMaxLength(128)
                         .HasColumnType("nvarchar(128)");
 
+                    b.Property<int?>("ServiceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ServiceNameSnapshot")
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
                     b.Property<string>("ServiceNotes")
                         .HasMaxLength(4000)
                         .HasColumnType("nvarchar(4000)");
@@ -2765,6 +2887,8 @@ namespace Data.SeaHavenIndustries.Migrations
 
                     b.HasIndex("ScheduledDate");
 
+                    b.HasIndex("ServiceId");
+
                     b.HasIndex("SiteCode")
                         .HasFilter("[istemplate] = 0");
 
@@ -3610,6 +3734,27 @@ namespace Data.SeaHavenIndustries.Migrations
                     b.Navigation("Quotes");
                 });
 
+            modelBuilder.Entity("Data.SeaHavenIndustries.Service", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.CompletionDocTemplate", "CompletionDocTemplate")
+                        .WithMany()
+                        .HasForeignKey("CompletionDocTemplateId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("CompletionDocTemplate");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.ServiceWorkOrderType", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Service", "Service")
+                        .WithMany("SupportedWorkOrderTypes")
+                        .HasForeignKey("ServiceId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Service");
+                });
+
             modelBuilder.Entity("Data.SeaHavenIndustries.SitePreferredVendor", b =>
                 {
                     b.HasOne("Data.SeaHavenIndustries.Locations", "Location")
@@ -3784,6 +3929,11 @@ namespace Data.SeaHavenIndustries.Migrations
                         .HasForeignKey("PrimaryDispatchId")
                         .OnDelete(DeleteBehavior.Restrict);
 
+                    b.HasOne("Data.SeaHavenIndustries.Service", "ServiceDefinition")
+                        .WithMany()
+                        .HasForeignKey("ServiceId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
                     b.Navigation("Account");
 
                     b.Navigation("AssignToUser");
@@ -3791,6 +3941,8 @@ namespace Data.SeaHavenIndustries.Migrations
                     b.Navigation("Locations");
 
                     b.Navigation("PrimaryDispatch");
+
+                    b.Navigation("ServiceDefinition");
                 });
 
             modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderAttachments", b =>
@@ -4012,6 +4164,11 @@ namespace Data.SeaHavenIndustries.Migrations
                     b.Navigation("Employees");
                 });
 
+            modelBuilder.Entity("Data.SeaHavenIndustries.Service", b =>
+                {
+                    b.Navigation("SupportedWorkOrderTypes");
+                });
+
             modelBuilder.Entity("Data.SeaHavenIndustries.TaskListTemplate", b =>
                 {
                     b.Navigation("Items");

Data.SeaHavenIndustries/Models/Service.cs

@@ -0,0 +1,29 @@
+using Data.SeaHavenIndustries.Enums;
+
+namespace Data.SeaHavenIndustries
+{
+    // Global (tenant-scope free) Services registry. Services are never
+    // hard deleted; deactivation is a soft IsActive state change so historical
+    // work-order references remain resolvable.
+    public class Service : FullAuditEntity
+    {
+        public string Name { get; set; } = "";
+        public string NormalizedName { get; set; } = "";
+        public string Trade { get; set; } = "";
+        public string IconKey { get; set; } = "";
+        public bool RequiresCompletionDocument { get; set; }
+        public int? CompletionDocTemplateId { get; set; }
+        public virtual CompletionDocTemplate? CompletionDocTemplate { get; set; }
+        public bool IsActive { get; set; } = true;
+        public virtual ICollection<ServiceWorkOrderType> SupportedWorkOrderTypes { get; set; } = new List<ServiceWorkOrderType>();
+    }
+
+    // Supported work-order types (PM, Reactive, Emergency) stored as an
+    // explicitly queryable relation so work-order features can filter by type.
+    public class ServiceWorkOrderType : FullAuditEntity
+    {
+        public int ServiceId { get; set; }
+        public virtual Service? Service { get; set; }
+        public WorkOrderType WorkOrderType { get; set; }
+    }
+}

Data.SeaHavenIndustries/Models/WorkerOrder.cs

@@ -43,6 +43,11 @@ namespace Data.SeaHavenIndustries
         /// <summary>SHOC board "Service" column (PM type label). Not Trade/Problem.</summary>
         [MaxLength(128)]
         public string? Service { get; set; }
+        public int? ServiceId { get; set; }
+        [MaxLength(200)]
+        public string? ServiceNameSnapshot { get; set; }
+        [ForeignKey(nameof(ServiceId))]
+        public virtual Service? ServiceDefinition { get; set; }
         public int? PrimaryDispatchId { get; set; }
         [ForeignKey(nameof(PrimaryDispatchId))]
         public virtual Dispatch? PrimaryDispatch { get; set; }

SeaHaven.DataServices/Helpers/WorkOrderBoardProjection.cs

@@ -34,6 +34,8 @@ namespace SeaHaven.DataServices.Helpers
                     w.OriginalDate,
                     w.OriginalWeek,
                     w.WorkOrderType,
+                    w.ServiceId,
+                    w.ServiceNameSnapshot,
                     w.SiteCode,
                     LocationName = w.Locations != null ? w.Locations.Name : null,
                     WoPocName = w.PocName,
@@ -136,6 +138,8 @@ namespace SeaHaven.DataServices.Helpers
                     w.CarriedOver,
                     w.IsAddOn,
                     w.WorkOrderType,
+                    w.ServiceId,
+                    w.ServiceNameSnapshot,
                     frozenSite?.Code ?? w.SiteCode,
                     frozenSite?.Label ?? w.LocationName,
                     pocName,

SeaHaven.DataServices/Implementation/DashboardDataService.cs

@@ -88,6 +88,70 @@ namespace SeaHaven.DataServices.Implementation
                 .ToListAsync(cancellationToken);
         }
 
+        public async Task<DashboardKpiCounts> GetKpiCountsAsync(
+            int? accountId,
+            string? dispatcherId,
+            DateOnly today,
+            CancellationToken cancellationToken)
+        {
+            var tomorrow = today.AddDays(1);
+            var dayAfterTomorrow = tomorrow.AddDays(1);
+            var workOrders = WorkOrderBoardQueryFilters.ApplyBaseScope(_context.workOrders.AsNoTracking());
+            if (accountId is int scopedAccountId)
+                workOrders = WorkOrderBoardQueryFilters.ApplyAccountScope(workOrders, scopedAccountId);
+            if (dispatcherId != null)
+                workOrders = workOrders.Where(w => w.AssignTo == dispatcherId);
+
+            var scheduledTomorrow = await workOrders
+                .Where(w => w.ScheduledDate >= tomorrow.ToDateTime(TimeOnly.MinValue)
+                    && w.ScheduledDate < dayAfterTomorrow.ToDateTime(TimeOnly.MinValue))
+                .CountAsync(cancellationToken);
+
+            var avetaPending = await workOrders
+                .Where(w => w.ScheduledDate >= today.ToDateTime(TimeOnly.MinValue)
+                    && w.ScheduledDate < dayAfterTomorrow.ToDateTime(TimeOnly.MinValue)
+                    && w.AvetaRequired
+                    && w.LifecycleStatus != LifecycleStatus.Completed
+                    && w.LifecycleStatus != LifecycleStatus.Canceled
+                    && (w.LifecycleStatus != null
+                        || ((w.LegacyStatus ?? w.Status) != "Done"
+                            && (w.LegacyStatus ?? w.Status) != "Completed"
+                            && (w.LegacyStatus ?? w.Status) != "Complete"
+                            && (w.LegacyStatus ?? w.Status) != "Closed"
+                            && (w.LegacyStatus ?? w.Status) != "Canceled"
+                            && (w.LegacyStatus ?? w.Status) != "Cancelled"))
+                    && !w.workOrderAttachments!.Any(attachment =>
+                        (attachment.IsDeleted == null || attachment.IsDeleted == false)
+                        && attachment.Category == WorkOrderMediaCategory.Aveta))
+                .CountAsync(cancellationToken);
+
+            var pendingUplifts = _context.DispatchUpliftRequests
+                .AsNoTracking()
+                .Where(request => request.Status == "Pending"
+                    && (request.IsDeleted == null || request.IsDeleted == false)
+                    && request.Dispatch != null
+                    && (request.Dispatch.IsDeleted == null || request.Dispatch.IsDeleted == false));
+            if (accountId is int account)
+            {
+                pendingUplifts = pendingUplifts.Where(request =>
+                    (request.Dispatch!.WorkOrder != null && request.Dispatch.WorkOrder.AccountId == account)
+                    || request.Dispatch.DispatchWorkOrders!.Any(link =>
+                        link.WorkOrder != null && link.WorkOrder.AccountId == account));
+            }
+            if (dispatcherId != null)
+            {
+                pendingUplifts = pendingUplifts.Where(request =>
+                    (request.Dispatch!.WorkOrder != null && request.Dispatch.WorkOrder.AssignTo == dispatcherId)
+                    || request.Dispatch.DispatchWorkOrders!.Any(link =>
+                        link.WorkOrder != null && link.WorkOrder.AssignTo == dispatcherId));
+            }
+
+            return new DashboardKpiCounts(
+                scheduledTomorrow,
+                await pendingUplifts.CountAsync(cancellationToken),
+                avetaPending);
+        }
+
         public async Task<IReadOnlyList<DashboardDispatcherWorkload>> GetDispatcherWorkloadAsync(
             int? accountId,
             string? dispatcherId,

SeaHaven.DataServices/Implementation/LocationDataService.cs

@@ -136,15 +136,21 @@ namespace SeaHaven.DataServices.Implementation
             int pageSize,
             string? search,
             IReadOnlyCollection<string>? states,
-            CancellationToken cancellationToken)
+            CancellationToken cancellationToken,
+            string? sortBy = null,
+            string? sortDirection = null)
         {
-            var query = _context.Locations.AsNoTracking();
+            IQueryable<Locations> query = _context.Locations
+                .AsNoTracking()
+                .Include(l => l.Account);
 
             if (!string.IsNullOrWhiteSpace(search))
             {
                 query = query.Where(l =>
                     l.Name!.Contains(search) ||
-                    l.City!.Contains(search));
+                    l.Address1!.Contains(search) ||
+                    l.City!.Contains(search) ||
+                    l.Account != null && l.Account.Name!.Contains(search));
             }
 
             if (states is { Count: > 0 })
@@ -152,9 +158,10 @@ namespace SeaHaven.DataServices.Implementation
                 query = query.Where(l => l.State != null && states.Contains(l.State.Trim().ToUpper()));
             }
 
+            query = ApplyListSort(query, sortBy, sortDirection);
+
             var totalCount = await query.CountAsync(cancellationToken);
             var items = await query
-                .OrderBy(l => l.Name)
                 .Skip((page - 1) * pageSize)
                 .Take(pageSize)
                 .ToListAsync(cancellationToken);
@@ -162,6 +169,33 @@ namespace SeaHaven.DataServices.Implementation
             return (items, totalCount);
         }
 
+        private static IQueryable<Locations> ApplyListSort(IQueryable<Locations> query, string? sortBy, string? sortDirection)
+        {
+            var descending = string.Equals(sortDirection?.Trim(), "desc", StringComparison.OrdinalIgnoreCase);
+            IOrderedQueryable<Locations> ordered = (sortBy?.Trim().ToLowerInvariant()) switch
+            {
+                "code" => descending ? query.OrderByDescending(l => l.Name) : query.OrderBy(l => l.Name),
+                "client" => descending ? query.OrderByDescending(l => l.Account!.Name) : query.OrderBy(l => l.Account!.Name),
+                "address" => descending ? query.OrderByDescending(l => l.Address1) : query.OrderBy(l => l.Address1),
+                "city" => descending ? query.OrderByDescending(l => l.City) : query.OrderBy(l => l.City),
+                "state" => descending ? query.OrderByDescending(l => l.State) : query.OrderBy(l => l.State),
+                "poc" => descending
+                    ? query.OrderByDescending(FirstActiveContactName)
+                    : query.OrderBy(FirstActiveContactName),
+                _ => query.OrderBy(l => l.Name)
+            };
+
+            return ordered.ThenBy(l => l.Id);
+        }
+
+        private static readonly System.Linq.Expressions.Expression<Func<Locations, string?>> FirstActiveContactName =
+            l => l.Contacts
+                .Where(c => c.IsDeleted != true)
+                .OrderBy(c => c.SiteContactOrder)
+                .ThenBy(c => c.Id)
+                .Select(c => c.FirstName)
+                .FirstOrDefault();
+
         public async Task<Locations?> GetDetailByIdAsync(int id, CancellationToken cancellationToken)
         {
             return await _context.Locations

SeaHaven.DataServices/Implementation/ServicesRegistryDataService.cs

@@ -0,0 +1,155 @@
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+using Microsoft.EntityFrameworkCore;
+using SeaHaven.DataServices.Interfaces;
+using SeaHaven.DataServices.Models;
+
+namespace SeaHaven.DataServices.Implementation
+{
+    public class ServicesRegistryDataService : IServicesRegistryDataService
+    {
+        private readonly ApplicationDbContext _context;
+
+        public ServicesRegistryDataService(ApplicationDbContext context)
+        {
+            _context = context;
+        }
+
+        public async Task<IReadOnlyList<ServiceRegistryRow>> GetServiceRowsAsync(bool? isActive, WorkOrderType? workOrderType, CancellationToken cancellationToken)
+        {
+            var query = _context.Services
+                .AsNoTracking()
+                .Where(s => s.IsDeleted != true);
+
+            if (isActive.HasValue)
+                query = query.Where(s => s.IsActive == isActive.Value);
+
+            if (workOrderType.HasValue)
+                query = query.Where(s => s.SupportedWorkOrderTypes.Any(t => t.WorkOrderType == workOrderType.Value));
+
+            var rows = await query
+                .OrderBy(s => s.Name)
+                .Select(s => new ServiceRegistryRow
+                {
+                    Id = s.Id,
+                    Name = s.Name,
+                    Trade = s.Trade,
+                    IconKey = s.IconKey,
+                    RequiresCompletionDocument = s.RequiresCompletionDocument,
+                    IsActive = s.IsActive,
+                    CompletionDocTemplateId = s.CompletionDocTemplateId,
+                    CompletionDocTemplateName = s.CompletionDocTemplate != null ? s.CompletionDocTemplate.Name : null,
+                    SupportedWorkOrderTypes = s.SupportedWorkOrderTypes.Select(t => t.WorkOrderType).ToList()
+                })
+                .ToListAsync(cancellationToken);
+            return rows;
+        }
+
+        public async Task<ServiceRegistryRow?> GetServiceRowByIdAsync(int id, CancellationToken cancellationToken)
+        {
+            return await _context.Services.AsNoTracking()
+                .Where(s => s.Id == id && s.IsDeleted != true)
+                .Select(s => new ServiceRegistryRow
+                {
+                    Id = s.Id,
+                    Name = s.Name,
+                    Trade = s.Trade,
+                    IconKey = s.IconKey,
+                    RequiresCompletionDocument = s.RequiresCompletionDocument,
+                    IsActive = s.IsActive,
+                    CompletionDocTemplateId = s.CompletionDocTemplateId,
+                    CompletionDocTemplateName = s.CompletionDocTemplate != null ? s.CompletionDocTemplate.Name : null,
+                    SupportedWorkOrderTypes = s.SupportedWorkOrderTypes.Select(t => t.WorkOrderType).ToList()
+                })
+                .FirstOrDefaultAsync(cancellationToken);
+        }
+
+        public async Task<Service?> GetServiceForUpdateAsync(int id, CancellationToken cancellationToken)
+        {
+            return await _context.Services
+                .Include(s => s.SupportedWorkOrderTypes)
+                .FirstOrDefaultAsync(s => s.Id == id && s.IsDeleted != true, cancellationToken);
+        }
+
+        public async Task<bool> NormalizedNameExistsAsync(string normalizedName, int? excludeServiceId, CancellationToken cancellationToken)
+        {
+            return await _context.Services
+                .AnyAsync(s => s.IsDeleted != true
+                               && s.NormalizedName == normalizedName
+                               && (excludeServiceId == null || s.Id != excludeServiceId),
+                    cancellationToken);
+        }
+
+        public async Task<LinkedTemplateSummary?> GetActiveTemplateSummaryAsync(int templateId, CancellationToken cancellationToken)
+        {
+            return await _context.CompletionDocTemplates
+                .Where(t => t.Id == templateId && t.IsActive && t.IsDeleted != true)
+                .Select(t => new LinkedTemplateSummary { Id = t.Id, Name = t.Name })
+                .FirstOrDefaultAsync(cancellationToken);
+        }
+
+        public async Task<Service> AddServiceAsync(Service service, CancellationToken cancellationToken)
+        {
+            await _context.Services.AddAsync(service, cancellationToken);
+            try
+            {
+                await _context.SaveChangesAsync(cancellationToken);
+            }
+            catch (DbUpdateException ex) when (IsUniqueNameViolation(ex))
+            {
+                throw new ServicesRegistryDuplicateNameException(ex);
+            }
+
+            return service;
+        }
+
+        public async Task SaveServiceAsync(Service service, IReadOnlyCollection<WorkOrderType> supportedWorkOrderTypes, CancellationToken cancellationToken)
+        {
+            var desired = supportedWorkOrderTypes.Distinct().ToList();
+            var current = service.SupportedWorkOrderTypes ?? new List<ServiceWorkOrderType>();
+
+            var stale = current.Where(t => !desired.Contains(t.WorkOrderType)).ToList();
+            _context.ServiceWorkOrderTypes.RemoveRange(stale);
+
+            var existingTypes = current.Select(t => t.WorkOrderType).ToHashSet();
+            foreach (var type in desired.Where(t => !existingTypes.Contains(t)))
+            {
+                _context.ServiceWorkOrderTypes.Add(new ServiceWorkOrderType
+                {
+                    ServiceId = service.Id,
+                    WorkOrderType = type
+                });
+            }
+
+            try
+            {
+                await _context.SaveChangesAsync(cancellationToken);
+            }
+            catch (DbUpdateException ex) when (IsUniqueNameViolation(ex))
+            {
+                throw new ServicesRegistryDuplicateNameException(ex);
+            }
+        }
+
+        public async Task<bool> DeactivateServiceAsync(int id, CancellationToken cancellationToken)
+        {
+            var service = await _context.Services
+                .FirstOrDefaultAsync(s => s.Id == id && s.IsDeleted != true, cancellationToken);
+            if (service == null)
+                return false;
+
+            service.IsActive = false;
+            await _context.SaveChangesAsync(cancellationToken);
+            return true;
+        }
+
+        private static bool IsUniqueNameViolation(DbUpdateException exception)
+        {
+            var message = exception.InnerException?.Message ?? exception.Message;
+            return message.Contains("IX_Services_NormalizedName", StringComparison.OrdinalIgnoreCase)
+                || message.Contains("NormalizedName", StringComparison.OrdinalIgnoreCase)
+                   && (message.Contains("duplicate", StringComparison.OrdinalIgnoreCase)
+                       || message.Contains("unique", StringComparison.OrdinalIgnoreCase));
+        }
+    }
+}

SeaHaven.DataServices/Interfaces/IDashboardDataService.cs

@@ -8,6 +8,12 @@ namespace SeaHaven.DataServices.Interfaces
             int? accountId,
             CancellationToken cancellationToken);
 
+        Task<DashboardKpiCounts> GetKpiCountsAsync(
+            int? accountId,
+            string? dispatcherId,
+            DateOnly today,
+            CancellationToken cancellationToken);
+
         Task<IReadOnlyList<DashboardWorkOrder>> GetDashboardWorkOrdersAsync(
             int? accountId,
             string? dispatcherId,
@@ -53,4 +59,9 @@ namespace SeaHaven.DataServices.Interfaces
         public int NotDispatched { get; set; }
         public int Completed { get; set; }
     }
+
+    public sealed record DashboardKpiCounts(
+        int ScheduledTomorrow,
+        int PendingUplifts,
+        int AvetaPending);
 }

SeaHaven.DataServices/Interfaces/ILocationDataService.cs

@@ -34,7 +34,11 @@ namespace SeaHaven.DataServices.Interfaces
         Task<bool> ExistsAsync(int id);
         Task<int> CountAsync();
 
-        Task<(List<Locations> Items, int TotalCount)> GetListPagedAsync(int page, int pageSize, string? search, IReadOnlyCollection<string>? states, CancellationToken cancellationToken);
+        /// <summary>
+        /// Sort keys are validated upstream; unknown or null keys fall back to the legacy code order.
+        /// Sort options trail the token so existing call sites stay source-compatible.
+        /// </summary>
+        Task<(List<Locations> Items, int TotalCount)> GetListPagedAsync(int page, int pageSize, string? search, IReadOnlyCollection<string>? states, CancellationToken cancellationToken, string? sortBy = null, string? sortDirection = null);
         Task<Locations?> GetDetailByIdAsync(int id, CancellationToken cancellationToken);
         Task<Locations?> GetByIdForUpdateAsync(int id, CancellationToken cancellationToken);
 

SeaHaven.DataServices/Interfaces/IServicesRegistryDataService.cs

@@ -0,0 +1,39 @@
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+
+namespace SeaHaven.DataServices.Interfaces
+{
+    // Read-side projection for the global Services registry. The linked
+    // completion template is projected to id/name only — full template
+    // entities are never materialized.
+    public class ServiceRegistryRow
+    {
+        public int Id { get; set; }
+        public string Name { get; set; } = "";
+        public string Trade { get; set; } = "";
+        public string IconKey { get; set; } = "";
+        public bool RequiresCompletionDocument { get; set; }
+        public bool IsActive { get; set; }
+        public int? CompletionDocTemplateId { get; set; }
+        public string? CompletionDocTemplateName { get; set; }
+        public List<WorkOrderType> SupportedWorkOrderTypes { get; set; } = new();
+    }
+
+    public class LinkedTemplateSummary
+    {
+        public int Id { get; set; }
+        public string Name { get; set; } = "";
+    }
+
+    public interface IServicesRegistryDataService
+    {
+        Task<IReadOnlyList<ServiceRegistryRow>> GetServiceRowsAsync(bool? isActive, WorkOrderType? workOrderType, CancellationToken cancellationToken);
+        Task<ServiceRegistryRow?> GetServiceRowByIdAsync(int id, CancellationToken cancellationToken);
+        Task<Service?> GetServiceForUpdateAsync(int id, CancellationToken cancellationToken);
+        Task<bool> NormalizedNameExistsAsync(string normalizedName, int? excludeServiceId, CancellationToken cancellationToken);
+        Task<LinkedTemplateSummary?> GetActiveTemplateSummaryAsync(int templateId, CancellationToken cancellationToken);
+        Task<Service> AddServiceAsync(Service service, CancellationToken cancellationToken);
+        Task SaveServiceAsync(Service service, IReadOnlyCollection<WorkOrderType> supportedWorkOrderTypes, CancellationToken cancellationToken);
+        Task<bool> DeactivateServiceAsync(int id, CancellationToken cancellationToken);
+    }
+}

SeaHaven.DataServices/Interfaces/WorkOrderBoardModels.cs

@@ -21,6 +21,8 @@ namespace SeaHaven.DataServices.Interfaces
         int CarriedOver,
         bool IsAddOn,
         WorkOrderType? WorkOrderType,
+        int? ServiceId,
+        string? ServiceNameSnapshot,
         string? SiteCode,
         string? LocationName,
         string? PocName,

SeaHaven.DataServices/Models/ServicesRegistryModels.cs

@@ -0,0 +1,14 @@
+namespace SeaHaven.DataServices.Models
+{
+    /// <summary>
+    /// Raised by the registry data service when the database unique name index
+    /// wins a concurrent create or update race.
+    /// </summary>
+    public sealed class ServicesRegistryDuplicateNameException : Exception
+    {
+        public ServicesRegistryDuplicateNameException(Exception innerException)
+            : base("A service name is already in use.", innerException)
+        {
+        }
+    }
+}

SeaHaven.Services/DTOs/DashboardDTOs.cs

@@ -100,6 +100,9 @@ namespace SeaHaven.Services.DTOs
         public int Open { get; set; }
         public int NotDispatched { get; set; }
         public int Completed { get; set; }
+        public int ScheduledTomorrow { get; set; }
+        public int PendingUplifts { get; set; }
+        public int AvetaPending { get; set; }
         public DashboardBreakdownDTO Breakdown { get; set; } = new();
         public int DueCount { get; set; }
         public int CompletedDueCount { get; set; }

SeaHaven.Services/DTOs/LocationDTOs.cs

@@ -14,6 +14,7 @@ namespace SeaHaven.Services.DTOs
         public string? Email { get; set; }
         public string? Status { get; set; }
         public int? AccountId { get; set; }
+        public string? AccountName { get; set; }
         public DateTime? CreatedDate { get; set; }
         public string? CreatedBy { get; set; }
 

SeaHaven.Services/DTOs/ServicesRegistryDTOs.cs

@@ -0,0 +1,39 @@
+using Data.SeaHavenIndustries.Enums;
+
+namespace SeaHaven.Services.DTOs
+{
+    public class ServiceDto
+    {
+        public int Id { get; set; }
+        public string Name { get; set; } = "";
+        public string Trade { get; set; } = "";
+        public string IconKey { get; set; } = "";
+        public bool RequiresCompletionDocument { get; set; }
+        public LinkedTemplateSummaryDto? CompletionDocTemplate { get; set; }
+        public bool IsActive { get; set; }
+        public List<WorkOrderType> SupportedWorkOrderTypes { get; set; } = new();
+    }
+
+    public class LinkedTemplateSummaryDto
+    {
+        public int Id { get; set; }
+        public string Name { get; set; } = "";
+    }
+
+    public class ServiceInput
+    {
+        public string? Name { get; set; }
+        public string? Trade { get; set; }
+        public string? IconKey { get; set; }
+        public bool RequiresCompletionDocument { get; set; }
+        public int? CompletionDocTemplateId { get; set; }
+        public List<WorkOrderType>? SupportedWorkOrderTypes { get; set; }
+        public bool? IsActive { get; set; }
+    }
+
+    public class ServicesRegistryValidationErrorDto
+    {
+        public string Code { get; set; } = "";
+        public string Message { get; set; } = "";
+    }
+}

SeaHaven.Services/DTOs/WorkOrderBoardDTOs.cs

@@ -84,6 +84,8 @@ namespace SeaHaven.Services.DTOs
         public DateOnly? OriginalDate { get; set; }
         public DateOnly? OriginalWeek { get; set; }
         public WorkOrderType? WorkOrderType { get; set; }
+        public int? ServiceId { get; set; }
+        public string? ServiceNameSnapshot { get; set; }
         public bool IsPastDue { get; set; }
         public string? SiteCode { get; set; }
         public string? LocationName { get; set; }

SeaHaven.Services/DTOs/WorkOrderBoardRequestDTOs.cs

@@ -30,6 +30,7 @@ namespace SeaHaven.Services.DTOs
         public string? Trade { get; set; }
         /// <summary>Primary service label; persisted as Trade / board pm.</summary>
         public string? PrimaryService { get; set; }
+        public int? ServiceId { get; set; }
         public List<string>? ExtraServices { get; set; }
         public string? ServiceNotes { get; set; }
         /// <summary>Per-WO Aveta compliance. Omit or false = not required.</summary>

SeaHaven.Services/Exceptions/ServicesRegistryExceptions.cs

@@ -0,0 +1,12 @@
+namespace SeaHaven.Services.Exceptions
+{
+    public class ServicesRegistryValidationException : Exception
+    {
+        public ServicesRegistryValidationException(string code, string message) : base(message)
+        {
+            Code = code;
+        }
+
+        public string Code { get; }
+    }
+}

SeaHaven.Services/Helpers/DashboardRegions.cs

@@ -9,10 +9,11 @@ public static class DashboardRegions
 
     public static string Resolve(string? state)
     {
-        if (string.IsNullOrWhiteSpace(state))
+        var code = UsStateCodes.ToCode(state);
+        if (code is null)
             return "Unmapped/Other";
 
-        return StateToRegion.TryGetValue(state.Trim().ToUpperInvariant(), out var region)
+        return StateToRegion.TryGetValue(code, out var region)
             ? region
             : "Unmapped/Other";
     }

SeaHaven.Services/Helpers/UsStateCodes.cs

@@ -56,8 +56,29 @@ namespace SeaHaven.Services.Helpers
             ["WY"] = "WYOMING"
         };
 
+        private static readonly IReadOnlyDictionary<string, string> CodesByName =
+            Names.ToDictionary(pair => pair.Value, pair => pair.Key, StringComparer.Ordinal);
+
         public static IReadOnlySet<string> All { get; } = new HashSet<string>(Names.Keys, StringComparer.Ordinal);
 
+        /// <summary>
+        /// Normalises a stored state value to its two-letter postal code. Accepts either a
+        /// postal code ("IN") or a full state name ("Indiana"), case-insensitively, matching
+        /// the storage forms produced by <see cref="ExpandStorageValues"/>. Returns null when
+        /// the value is blank or is not a recognised US state.
+        /// </summary>
+        public static string? ToCode(string? value)
+        {
+            if (string.IsNullOrWhiteSpace(value))
+                return null;
+
+            var normalized = value.Trim().ToUpperInvariant();
+            if (All.Contains(normalized))
+                return normalized;
+
+            return CodesByName.TryGetValue(normalized, out var code) ? code : null;
+        }
+
         public static IReadOnlyCollection<string> ExpandStorageValues(IEnumerable<string> codes)
         {
             return codes

SeaHaven.Services/Helpers/WorkOrderBoardFieldNames.cs

@@ -17,6 +17,7 @@ namespace SeaHaven.Services.Helpers
         public const string DocStatus = "docStatus";
         public const string CompletedDate = "completedDate";
         public const string Pm = "pm";
+        public const string ServiceId = "serviceId";
         public const string ServiceNotes = "serviceNotes";
         public const string ExtraServices = "extraServices";
         public const string AdditionalContacts = "additionalContacts";
@@ -49,6 +50,7 @@ namespace SeaHaven.Services.Helpers
             DocStatus,
             CompletedDate,
             Pm,
+            ServiceId,
             ServiceNotes,
             ExtraServices,
             AdditionalContacts,
@@ -93,6 +95,7 @@ namespace SeaHaven.Services.Helpers
                 DocStatus => "DocStatus",
                 CompletedDate => "CompletedDate",
                 Pm => "Trade",
+                ServiceId => "ServiceId",
                 ServiceNotes => "ServiceNotes",
                 ExtraServices => "ExtraServices",
                 AdditionalContacts => "AdditionalContacts",

SeaHaven.Services/Implementation/DashboardService.cs

@@ -35,6 +35,11 @@ namespace SeaHaven.Services.Implementation
                 throw new WorkOrderBoardValidationException("Forbidden", "Dispatcher identity is required.");
 
             var counts = await _dataService.GetWorkOrderCountsAsync(accountId, cancellationToken);
+            var kpis = await _dataService.GetKpiCountsAsync(
+                accountId,
+                dispatcherId,
+                DashboardBusinessTime.Today(),
+                cancellationToken);
             var workOrders = await _dataService.GetDashboardWorkOrdersAsync(
                 accountId,
                 dispatcherId,
@@ -51,6 +56,9 @@ namespace SeaHaven.Services.Implementation
                 Open = useMetrics ? metrics.Open : counts.Open,
                 NotDispatched = useMetrics ? metrics.NotDispatched : counts.NotDispatched,
                 Completed = useMetrics ? metrics.Completed : counts.Completed,
+                ScheduledTomorrow = kpis.ScheduledTomorrow,
+                PendingUplifts = kpis.PendingUplifts,
+                AvetaPending = kpis.AvetaPending,
                 Breakdown = metrics.Breakdown,
                 DueCount = metrics.DueCount,
                 CompletedDueCount = metrics.CompletedDueCount,

SeaHaven.Services/Implementation/LocationService.cs

@@ -166,11 +166,15 @@ namespace SeaHaven.Services.Implementation
             int pageSize,
             string? search,
             string? states = null,
-            CancellationToken cancellationToken = default)
+            CancellationToken cancellationToken = default,
+            string? sortBy = null,
+            string? sortDirection = null)
         {
             var stateFilter = NormalizeStateFilter(states);
             var storageStateFilter = stateFilter == null ? null : UsStateCodes.ExpandStorageValues(stateFilter);
-            var (items, totalCount) = await _locationDataService.GetListPagedAsync(page, pageSize, search, storageStateFilter, cancellationToken);
+            var sort = NormalizeSortColumn(sortBy);
+            var direction = NormalizeSortDirection(sortDirection);
+            var (items, totalCount) = await _locationDataService.GetListPagedAsync(page, pageSize, search, storageStateFilter, cancellationToken, sort, direction);
 
             // SH-138: one bounded contact read for the whole page, never per row.
             var contactsByLocation = await GetSiteContactsByLocationIdsAsync(items, cancellationToken);
@@ -184,6 +188,42 @@ namespace SeaHaven.Services.Implementation
             };
         }
 
+        internal static readonly IReadOnlyCollection<string> SortableColumns = new[] { "code", "client", "address", "city", "state", "poc" };
+
+        internal static string? NormalizeSortColumn(string? sortBy)
+        {
+            if (string.IsNullOrWhiteSpace(sortBy))
+                return null;
+
+            var normalized = sortBy.Trim().ToLowerInvariant();
+            if (!SortableColumns.Contains(normalized))
+            {
+                throw new ValidationException(new[]
+                {
+                    new ValidationFailure("sortBy", $"sortBy must be one of: {string.Join(", ", SortableColumns)}.")
+                });
+            }
+
+            return normalized;
+        }
+
+        internal static string NormalizeSortDirection(string? sortDirection)
+        {
+            if (string.IsNullOrWhiteSpace(sortDirection))
+                return "asc";
+
+            var normalized = sortDirection.Trim().ToLowerInvariant();
+            if (normalized != "asc" && normalized != "desc")
+            {
+                throw new ValidationException(new[]
+                {
+                    new ValidationFailure("sortDirection", "sortDirection must be asc or desc.")
+                });
+            }
+
+            return normalized;
+        }
+
         internal static IReadOnlyCollection<string>? NormalizeStateFilter(string? states)
         {
             if (string.IsNullOrWhiteSpace(states))
@@ -503,6 +543,7 @@ namespace SeaHaven.Services.Implementation
                 Email = location.Email,
                 Status = location.Status,
                 AccountId = location.AccountId,
+                AccountName = location.Account?.Name,
                 CreatedDate = location.CreatedDate,
                 CreatedBy = location.createdby,
                 Contacts = contactsByLocation != null && contactsByLocation.TryGetValue(location.Id, out var contacts)

SeaHaven.Services/Implementation/ServicesRegistryService.cs

@@ -0,0 +1,255 @@
+using System.Security.Claims;
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+using SeaHaven.DataServices.Interfaces;
+using SeaHaven.DataServices.Models;
+using SeaHaven.Services.DTOs;
+using SeaHaven.Services.Exceptions;
+using SeaHaven.Services.Interfaces;
+
+namespace SeaHaven.Services.Implementation
+{
+    public class ServicesRegistryService : IServicesRegistryService
+    {
+        // Product contract: the registry only accepts the three work-order types
+        // the product currently supports. Any other WorkOrderType is rejected.
+        public static readonly IReadOnlySet<WorkOrderType> AllowedWorkOrderTypes =
+            new HashSet<WorkOrderType> { WorkOrderType.PM, WorkOrderType.Reactive, WorkOrderType.Emergency };
+
+        private static readonly WorkOrderType[] DefaultSupportedWorkOrderTypes =
+            { WorkOrderType.PM, WorkOrderType.Reactive, WorkOrderType.Emergency };
+
+        public const string SchedulerRole = "Scheduler";
+        public const string AdminRole = "Admin";
+
+        private const int NameMaxLength = 200;
+        private const int IconKeyMaxLength = 64;
+
+        private readonly IServicesRegistryDataService _dataService;
+
+        public ServicesRegistryService(IServicesRegistryDataService dataService)
+        {
+            _dataService = dataService;
+        }
+
+        public async Task<IReadOnlyList<ServiceDto>> GetAllAsync(bool? isActive, WorkOrderType? workOrderType, CancellationToken cancellationToken)
+        {
+            ValidateWorkOrderTypeFilter(workOrderType);
+            var rows = await _dataService.GetServiceRowsAsync(isActive, workOrderType, cancellationToken);
+            return rows.Select(MapToDto).ToList();
+        }
+
+        public async Task<ServiceDto?> GetByIdAsync(int id, CancellationToken cancellationToken)
+        {
+            var row = await _dataService.GetServiceRowByIdAsync(id, cancellationToken);
+            return row == null ? null : MapToDto(row);
+        }
+
+        public async Task<ServiceDto> CreateAsync(ClaimsPrincipal user, ServiceInput input, CancellationToken cancellationToken)
+        {
+            EnsureCanMutate(user);
+
+            var name = RequireValidName(input.Name);
+            var trade = RequireCanonicalTrade(input.Trade);
+            var iconKey = RequireValidIconKey(input.IconKey);
+            var supportedTypes = RequireValidSupportedTypes(input.SupportedWorkOrderTypes);
+            var template = await ResolveTemplateLinkAsync(input, cancellationToken);
+
+            if (await _dataService.NormalizedNameExistsAsync(TradeCatalog.Normalize(name), null, cancellationToken))
+                throw new ServicesRegistryValidationException("DuplicateName", "A service with this name already exists.");
+
+            var service = new Service
+            {
+                Name = name,
+                NormalizedName = TradeCatalog.Normalize(name),
+                Trade = trade,
+                IconKey = iconKey,
+                RequiresCompletionDocument = input.RequiresCompletionDocument,
+                CompletionDocTemplateId = template?.Id,
+                IsActive = true,
+                SupportedWorkOrderTypes = supportedTypes
+                    .Select(t => new ServiceWorkOrderType { WorkOrderType = t })
+                    .ToList()
+            };
+
+            try
+            {
+                await _dataService.AddServiceAsync(service, cancellationToken);
+            }
+            catch (ServicesRegistryDuplicateNameException)
+            {
+                throw DuplicateName();
+            }
+
+            var row = await _dataService.GetServiceRowByIdAsync(service.Id, cancellationToken);
+            return MapToDto(row!);
+        }
+
+        public async Task<ServiceDto> UpdateAsync(ClaimsPrincipal user, int id, ServiceInput input, CancellationToken cancellationToken)
+        {
+            EnsureCanMutate(user);
+
+            var service = await _dataService.GetServiceForUpdateAsync(id, cancellationToken);
+            if (service == null || service.IsDeleted == true)
+                throw new ServicesRegistryValidationException("NotFound", "Service not found.");
+
+            var name = RequireValidName(input.Name);
+            var trade = RequireCanonicalTrade(input.Trade);
+            var iconKey = RequireValidIconKey(input.IconKey);
+            var supportedTypes = RequireValidSupportedTypes(input.SupportedWorkOrderTypes);
+            var template = await ResolveTemplateLinkAsync(input, cancellationToken);
+
+            if (await _dataService.NormalizedNameExistsAsync(TradeCatalog.Normalize(name), id, cancellationToken))
+                throw new ServicesRegistryValidationException("DuplicateName", "A service with this name already exists.");
+
+            service.Name = name;
+            service.NormalizedName = TradeCatalog.Normalize(name);
+            service.Trade = trade;
+            service.IconKey = iconKey;
+            service.RequiresCompletionDocument = input.RequiresCompletionDocument;
+            service.CompletionDocTemplateId = template?.Id;
+            if (input.IsActive.HasValue)
+            {
+                EnsureCanChangeActiveState(user);
+                service.IsActive = input.IsActive.Value;
+            }
+
+            try
+            {
+                await _dataService.SaveServiceAsync(service, supportedTypes, cancellationToken);
+            }
+            catch (ServicesRegistryDuplicateNameException)
+            {
+                throw DuplicateName();
+            }
+
+            var row = await _dataService.GetServiceRowByIdAsync(id, cancellationToken);
+            return MapToDto(row!);
+        }
+
+        public async Task DeactivateAsync(ClaimsPrincipal user, int id, CancellationToken cancellationToken)
+        {
+            if (user is null || !user.IsInRole(AdminRole))
+                throw new ServicesRegistryValidationException("Forbidden", "Only administrators can deactivate services.");
+
+            var deactivated = await _dataService.DeactivateServiceAsync(id, cancellationToken);
+            if (!deactivated)
+                throw new ServicesRegistryValidationException("NotFound", "Service not found.");
+        }
+
+        private static void EnsureCanMutate(ClaimsPrincipal user)
+        {
+            if (user is null || !(user.IsInRole(SchedulerRole) || user.IsInRole(AdminRole)))
+                throw new ServicesRegistryValidationException("Forbidden", "Scheduler or Admin role is required.");
+        }
+
+        private static void EnsureCanChangeActiveState(ClaimsPrincipal user)
+        {
+            if (user is null || !user.IsInRole(AdminRole))
+                throw new ServicesRegistryValidationException("Forbidden", "Only administrators can change service active state.");
+        }
+
+        private static ServicesRegistryValidationException DuplicateName() =>
+            new("DuplicateName", "A service with this name already exists.");
+
+        private static string RequireValidName(string? name)
+        {
+            if (string.IsNullOrWhiteSpace(name))
+                throw new ServicesRegistryValidationException("NameRequired", "Service name is required.");
+
+            var trimmed = name.Trim();
+            if (trimmed.Length > NameMaxLength)
+                throw new ServicesRegistryValidationException("NameInvalid", $"Service name cannot exceed {NameMaxLength} characters.");
+
+            return trimmed;
+        }
+
+        private static string RequireCanonicalTrade(string? trade)
+        {
+            if (string.IsNullOrWhiteSpace(trade))
+                throw new ServicesRegistryValidationException("TradeInvalid", "Trade must be one of the canonical trade values.");
+
+            var normalized = TradeCatalog.Normalize(trade);
+            var canonical = TradeCatalog.CanonicalTrades
+                .FirstOrDefault(t => TradeCatalog.Normalize(t) == normalized);
+
+            if (canonical == null)
+                throw new ServicesRegistryValidationException("TradeInvalid", "Trade must be one of the canonical trade values.");
+
+            return canonical;
+        }
+
+        private static string RequireValidIconKey(string? iconKey)
+        {
+            if (string.IsNullOrWhiteSpace(iconKey))
+                throw new ServicesRegistryValidationException("IconKeyInvalid", "Icon key is required.");
+
+            var trimmed = iconKey.Trim();
+            if (trimmed.Length > IconKeyMaxLength)
+                throw new ServicesRegistryValidationException("IconKeyInvalid", $"Icon key cannot exceed {IconKeyMaxLength} characters.");
+
+            return trimmed;
+        }
+
+        private static List<WorkOrderType> RequireValidSupportedTypes(IEnumerable<WorkOrderType>? supportedTypes)
+        {
+            // The registry form does not expose type categories yet. Until it
+            // does, an omitted or empty category list keeps a service available
+            // to the three supported work-order types.
+            var types = supportedTypes?.Distinct().ToList();
+            if (types == null || types.Count == 0)
+                return DefaultSupportedWorkOrderTypes.ToList();
+
+            if (types.Any(t => !AllowedWorkOrderTypes.Contains(t)))
+                throw new ServicesRegistryValidationException(
+                    "WorkOrderTypeInvalid",
+                    "Supported work order types may only include PM, Reactive, or Emergency.");
+
+            return types;
+        }
+
+        private static void ValidateWorkOrderTypeFilter(WorkOrderType? workOrderType)
+        {
+            if (workOrderType.HasValue && !AllowedWorkOrderTypes.Contains(workOrderType.Value))
+                throw new ServicesRegistryValidationException(
+                    "WorkOrderTypeInvalid",
+                    "Supported work order types may only include PM, Reactive, or Emergency.");
+        }
+
+        private async Task<LinkedTemplateSummary?> ResolveTemplateLinkAsync(ServiceInput input, CancellationToken cancellationToken)
+        {
+            // Toggle off clears/ignores any template link.
+            if (!input.RequiresCompletionDocument || input.CompletionDocTemplateId is not int templateId)
+                return null;
+
+            var template = await _dataService.GetActiveTemplateSummaryAsync(templateId, cancellationToken);
+            if (template == null)
+                throw new ServicesRegistryValidationException(
+                    "TemplateInvalid",
+                    "Completion document template must reference an active, non-deleted template.");
+
+            return template;
+        }
+
+        private static ServiceDto MapToDto(ServiceRegistryRow row)
+        {
+            return new ServiceDto
+            {
+                Id = row.Id,
+                Name = row.Name,
+                Trade = row.Trade,
+                IconKey = row.IconKey,
+                RequiresCompletionDocument = row.RequiresCompletionDocument,
+                CompletionDocTemplate = row.CompletionDocTemplateId == null
+                    ? null
+                    : new LinkedTemplateSummaryDto
+                    {
+                        Id = row.CompletionDocTemplateId.Value,
+                        Name = row.CompletionDocTemplateName ?? ""
+                    },
+                IsActive = row.IsActive,
+                SupportedWorkOrderTypes = row.SupportedWorkOrderTypes.OrderBy(t => (int)t).ToList()
+            };
+        }
+    }
+}

SeaHaven.Services/Implementation/TeamMemberService.cs

@@ -167,7 +167,7 @@ public sealed class TeamMemberService : ITeamMemberService
         if (roleError is not null)
             return OperationFailure(roleError);
 
-        user.FirstName = candidate.Name!.Trim();
+        ApplyName(user, candidate.Name!.Trim());
         user.Contact = candidate.Phone?.Trim();
         user.PhoneNumber = candidate.Phone?.Trim();
         user.Color = color;
@@ -215,6 +215,24 @@ public sealed class TeamMemberService : ITeamMemberService
         return await OperationSuccessAsync(user, caller, cancellationToken);
     }
 
+    private static void ApplyName(ApplicationUser user, string fullName)
+    {
+        var current = $"{user.FirstName ?? ""} {user.LastName ?? ""}".Trim();
+        if (string.Equals(fullName, current, StringComparison.Ordinal))
+            return;
+
+        var separator = fullName.IndexOf(' ');
+        if (separator < 0)
+        {
+            user.FirstName = fullName;
+            user.LastName = null;
+            return;
+        }
+
+        user.FirstName = fullName[..separator].Trim();
+        user.LastName = fullName[(separator + 1)..].Trim();
+    }
+
     private async Task<string?> EnsureRoleAsync(string role)
     {
         if (await _roleManager.RoleExistsAsync(role))

SeaHaven.Services/Implementation/WorkOrderBoardCreateService.cs

@@ -20,6 +20,7 @@ namespace SeaHaven.Services.Implementation
         private readonly IWorkOrderAuditService _auditService;
         private readonly IWorkOrderBoardCreateValidation _validator;
         private readonly IWorkOrderAccountResolver _accountResolver;
+        private readonly IServicesRegistryService? _servicesRegistryService;
 
         public WorkOrderBoardCreateService(
             IWorkOrderBoardDataService boardDataService,
@@ -27,7 +28,8 @@ namespace SeaHaven.Services.Implementation
             IWorkOrderBoardService boardService,
             IWorkOrderAuditService auditService,
             IWorkOrderBoardCreateValidation validator,
-            IWorkOrderAccountResolver accountResolver)
+            IWorkOrderAccountResolver accountResolver,
+            IServicesRegistryService? servicesRegistryService = null)
         {
             _boardDataService = boardDataService;
             _mutationData = mutationData;
@@ -35,6 +37,7 @@ namespace SeaHaven.Services.Implementation
             _auditService = auditService;
             _validator = validator;
             _accountResolver = accountResolver;
+            _servicesRegistryService = servicesRegistryService;
         }
 
         public async Task<WorkOrderBoardRowDto> CreateAsync(
@@ -54,7 +57,8 @@ namespace SeaHaven.Services.Implementation
 
             var woNumber = await ResolveWoNumberAsync(request.WoNumber, cancellationToken);
             var siteCode = request.SiteCode!.Trim();
-            var primaryService = ResolvePrimaryService(request);
+            var selectedService = await ResolveServiceAsync(request.ServiceId, request.WorkOrderType, request.PrimaryService ?? request.Trade, cancellationToken);
+            var primaryService = selectedService?.Name ?? ResolvePrimaryService(request);
             var extraServicesJson = SerializeExtraServices(request.ExtraServices);
             var serviceNotes = TrimOrNull(request.ServiceNotes);
             var pocName = TrimOrNull(request.PocName);
@@ -87,6 +91,8 @@ namespace SeaHaven.Services.Implementation
                 AccountId = accountId,
                 Description = string.IsNullOrWhiteSpace(request.Description) ? null : request.Description.Trim(),
                 Trade = primaryService,
+                ServiceId = selectedService?.Id,
+                ServiceNameSnapshot = selectedService?.Name,
                 ExtraServices = extraServicesJson,
                 ServiceNotes = serviceNotes,
                 AvetaRequired = request.AvetaRequired == true,
@@ -138,6 +144,8 @@ namespace SeaHaven.Services.Implementation
                 changes.Add(WorkOrderBoardFieldMutations.BoardFieldChange.Changed("Description", "", workOrder.Description));
             if (workOrder.Trade != null)
                 changes.Add(WorkOrderBoardFieldMutations.BoardFieldChange.Changed("Trade", "", workOrder.Trade));
+            if (workOrder.ServiceId.HasValue)
+                changes.Add(WorkOrderBoardFieldMutations.BoardFieldChange.Changed("ServiceId", "", workOrder.ServiceId.Value.ToString()));
             if (workOrder.ExtraServices != null)
                 changes.Add(WorkOrderBoardFieldMutations.BoardFieldChange.Changed("ExtraServices", "", workOrder.ExtraServices));
             if (workOrder.ServiceNotes != null)
@@ -251,6 +259,46 @@ namespace SeaHaven.Services.Implementation
             return null;
         }
 
+        private async Task<ServiceDto?> ResolveServiceAsync(
+            int? serviceId,
+            WorkOrderType workOrderType,
+            string? legacyLabel,
+            CancellationToken cancellationToken)
+        {
+            if (_servicesRegistryService == null)
+            {
+                if (serviceId.HasValue)
+                    throw new WorkOrderBoardValidationException("ServiceInvalid", "serviceId is not available.");
+                return null;
+            }
+
+            if (!ServicesRegistryService.AllowedWorkOrderTypes.Contains(workOrderType))
+            {
+                if (serviceId.HasValue)
+                    throw new WorkOrderBoardValidationException(
+                        "ServiceInvalid",
+                        "serviceId is not supported for this work order type.");
+                return null;
+            }
+
+            var services = await _servicesRegistryService.GetAllAsync(true, workOrderType, cancellationToken);
+            if (serviceId.HasValue)
+            {
+                var selected = services.FirstOrDefault(service => service.Id == serviceId.Value);
+                if (selected == null)
+                    throw new WorkOrderBoardValidationException(
+                        "ServiceInvalid",
+                        "serviceId must reference an active service that supports this work order type.");
+                return selected;
+            }
+
+            if (string.IsNullOrWhiteSpace(legacyLabel))
+                return null;
+
+            return services.FirstOrDefault(service =>
+                string.Equals(service.Name.Trim(), legacyLabel.Trim(), StringComparison.OrdinalIgnoreCase));
+        }
+
         private static string? SerializeExtraServices(List<string>? extras)
         {
             if (extras == null || extras.Count == 0)

SeaHaven.Services/Implementation/WorkOrderBoardService.cs

@@ -108,6 +108,8 @@ namespace SeaHaven.Services.Implementation
                 OriginalDate = row.OriginalDate,
                 OriginalWeek = row.OriginalWeek,
                 WorkOrderType = row.WorkOrderType,
+                ServiceId = row.ServiceId,
+                ServiceNameSnapshot = row.ServiceNameSnapshot,
                 IsPastDue = WorkOrderDerivedFields.IsPastDue(row.ScheduledDate, row.LifecycleStatus, utcNow),
                 SiteCode = row.SiteCode,
                 LocationName = row.LocationName,
@@ -136,7 +138,7 @@ namespace SeaHaven.Services.Implementation
                 TechPhone = row.TechPhone,
                 ApptDate = row.DispatchApptDate ?? row.ScheduledDate,
                 ApptTime = WorkOrderDerivedFields.FormatApptTime(apptStart, apptEnd),
-                Pm = row.Trade ?? row.Problem,
+                Pm = row.Trade ?? row.ServiceNameSnapshot ?? row.Problem,
                 ServiceNotes = row.ServiceNotes,
                 ExtraServices = ParseExtraServices(row.ExtraServices),
                 AdditionalContacts = MapAdditionalContacts(row),

SeaHaven.Services/Implementation/WorkOrderBoardUpdateService.cs

@@ -16,15 +16,18 @@ namespace SeaHaven.Services.Implementation
         private readonly IWorkOrderBoardDataService _boardDataService;
         private readonly IWorkOrderBoardMutationDataService _mutationData;
         private readonly IWorkOrderAuditService _auditService;
+        private readonly IServicesRegistryService? _servicesRegistryService;
 
         public WorkOrderBoardUpdateService(
             IWorkOrderBoardDataService boardDataService,
             IWorkOrderBoardMutationDataService mutationData,
-            IWorkOrderAuditService auditService)
+            IWorkOrderAuditService auditService,
+            IServicesRegistryService? servicesRegistryService = null)
         {
             _boardDataService = boardDataService;
             _mutationData = mutationData;
             _auditService = auditService;
+            _servicesRegistryService = servicesRegistryService;
         }
 
         public async Task<WorkOrderBoardRowDto> PatchFieldAsync(
@@ -73,6 +76,13 @@ namespace SeaHaven.Services.Implementation
 
                 _mutationData.SetExpectedWorkOrderVersion(workOrder, workOrderVersion);
 
+                if (canonicalField.Equals(WorkOrderBoardFieldNames.WorkOrderType, StringComparison.OrdinalIgnoreCase)
+                    && workOrder.ServiceId.HasValue)
+                {
+                    var nextType = ParseWorkOrderType(value: request.Value);
+                    await EnsureServiceSupportsTypeAsync(workOrder.ServiceId.Value, nextType, ct);
+                }
+
                 Dispatch? dispatch = null;
                 ResolvedDispatch? resolved = null;
                 if (WorkOrderBoardFieldNames.IsDispatchField(canonicalField))
@@ -181,6 +191,7 @@ namespace SeaHaven.Services.Implementation
             {
                 WorkOrderBoardFieldNames.WoNumber => new List<FieldChange> { await ApplyWoNumber(workOrder, value, auditField, cancellationToken) },
                 WorkOrderBoardFieldNames.WorkOrderType => ApplyWorkOrderType(workOrder, value, auditField),
+                WorkOrderBoardFieldNames.ServiceId => await ApplyServiceIdAsync(workOrder, value, auditField, cancellationToken),
                 WorkOrderBoardFieldNames.Severity => new List<FieldChange> { ApplySeverity(workOrder, value, auditField) },
                 WorkOrderBoardFieldNames.SiteCode => new List<FieldChange> { ApplyStringField(value, auditField, v => workOrder.SiteCode = v, () => workOrder.SiteCode) },
                 WorkOrderBoardFieldNames.LifecycleStatus => ApplyLifecycleStatus(workOrder, value, auditField),
@@ -388,6 +399,83 @@ namespace SeaHaven.Services.Implementation
             return changes;
         }
 
+        private async Task<List<FieldChange>> ApplyServiceIdAsync(
+            WorkOrder workOrder,
+            string? value,
+            string auditField,
+            CancellationToken cancellationToken)
+        {
+            if (_servicesRegistryService == null)
+                throw new WorkOrderBoardValidationException("ServiceInvalid", "Service registry is unavailable.");
+
+            if (string.IsNullOrWhiteSpace(value))
+            {
+                var previousServiceId = workOrder.ServiceId;
+                var previousServiceLabel = workOrder.ServiceNameSnapshot ?? workOrder.Trade;
+                workOrder.ServiceId = null;
+                workOrder.ServiceNameSnapshot = null;
+                workOrder.Trade = null;
+                return new List<FieldChange>
+                {
+                    FieldChange.ForField(auditField, previousServiceId?.ToString(), null),
+                    FieldChange.ForField("Trade", previousServiceLabel, null)
+                };
+            }
+
+            if (!int.TryParse(value.Trim(), out var serviceId) || serviceId <= 0)
+                throw new WorkOrderBoardValidationException("ServiceInvalid", "serviceId must be a positive integer.");
+
+            var service = await _servicesRegistryService.GetByIdAsync(serviceId, cancellationToken);
+            if (!ServicesRegistryService.AllowedWorkOrderTypes.Contains(workOrder.WorkOrderType ?? WorkOrderType.PM)
+                || service == null
+                || !service.IsActive
+                || !service.SupportedWorkOrderTypes.Contains(workOrder.WorkOrderType ?? WorkOrderType.PM))
+            {
+                throw new WorkOrderBoardValidationException(
+                    "ServiceInvalid",
+                    "serviceId must reference an active service that supports this work order type.");
+            }
+
+            var oldId = workOrder.ServiceId;
+            var oldLabel = workOrder.ServiceNameSnapshot ?? workOrder.Trade;
+            workOrder.ServiceId = service.Id;
+            workOrder.ServiceNameSnapshot = service.Name;
+            workOrder.Trade = service.Name;
+            return new List<FieldChange>
+            {
+                oldId == service.Id
+                    ? FieldChange.Unchanged(auditField)
+                    : FieldChange.ForField(auditField, oldId?.ToString(), service.Id.ToString()),
+                oldLabel == service.Name
+                    ? FieldChange.Unchanged("Trade")
+                    : FieldChange.ForField("Trade", oldLabel, service.Name)
+            };
+        }
+
+        private async Task EnsureServiceSupportsTypeAsync(int serviceId, WorkOrderType workOrderType, CancellationToken cancellationToken)
+        {
+            if (_servicesRegistryService == null)
+                throw new WorkOrderBoardValidationException("ServiceTypeInvalid", "Service registry is unavailable.");
+
+            var service = await _servicesRegistryService.GetByIdAsync(serviceId, cancellationToken);
+            if (service == null || !service.SupportedWorkOrderTypes.Contains(workOrderType))
+                throw new WorkOrderBoardValidationException(
+                    "ServiceTypeInvalid",
+                    "The selected service does not support this work order type.");
+        }
+
+        private static WorkOrderType ParseWorkOrderType(string? value)
+        {
+            if (string.IsNullOrWhiteSpace(value)
+                || string.Equals(value.Trim(), "Overdue", StringComparison.OrdinalIgnoreCase)
+                || !WorkOrderTypeMapper.TryParseFeLabel(value, out var parsed))
+            {
+                throw new WorkOrderBoardValidationException("InvalidValue", $"Invalid workOrderType: {value}");
+            }
+
+            return parsed;
+        }
+
         private static FieldChange ApplySeverity(WorkOrder workOrder, string? value, string auditField)
         {
             if (!WorkOrderSeverityRules.TryNormalize(value, out var normalized))

SeaHaven.Services/Interfaces/ILocationService.cs

@@ -19,7 +19,7 @@ namespace SeaHaven.Services.Interfaces
         Task<bool> LocationExistsAsync(int id);
         Task<int> GetTotalLocationCountAsync();
 
-        Task<PagedResult<LocationDTO>> GetLocationListPagedAsync(int page, int pageSize, string? search, string? states = null, CancellationToken cancellationToken = default);
+        Task<PagedResult<LocationDTO>> GetLocationListPagedAsync(int page, int pageSize, string? search, string? states = null, CancellationToken cancellationToken = default, string? sortBy = null, string? sortDirection = null);
         Task<LocationDTO?> GetLocationDetailAsync(int id, CancellationToken cancellationToken);
         Task CreateLocationFromRequestAsync(LocationCreateRequestDTO request, ClaimsPrincipal user, CancellationToken cancellationToken);
         Task UpdateLocationFromRequestAsync(int id, LocationUpdateRequestDTO request, ClaimsPrincipal user, CancellationToken cancellationToken);

SeaHaven.Services/Interfaces/IServicesRegistryService.cs

@@ -0,0 +1,19 @@
+using System.Security.Claims;
+using Data.SeaHavenIndustries.Enums;
+using SeaHaven.Services.DTOs;
+
+namespace SeaHaven.Services.Interfaces
+{
+    // Global Services registry. Tenant scope is global (no AccountId),
+    // matching DropdownOptions. Reads are authenticated; create/update require
+    // the Scheduler or Admin role and deactivation is Admin-only, enforced at
+    // this service entry — never in the controller alone.
+    public interface IServicesRegistryService
+    {
+        Task<IReadOnlyList<ServiceDto>> GetAllAsync(bool? isActive, WorkOrderType? workOrderType, CancellationToken cancellationToken);
+        Task<ServiceDto?> GetByIdAsync(int id, CancellationToken cancellationToken);
+        Task<ServiceDto> CreateAsync(ClaimsPrincipal user, ServiceInput input, CancellationToken cancellationToken);
+        Task<ServiceDto> UpdateAsync(ClaimsPrincipal user, int id, ServiceInput input, CancellationToken cancellationToken);
+        Task DeactivateAsync(ClaimsPrincipal user, int id, CancellationToken cancellationToken);
+    }
+}

SeaHavenIndustries.Tests/SH303ServicesRegistryMigrationTests.cs

@@ -0,0 +1,342 @@
+using System.Reflection;
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Migrations;
+using Microsoft.Data.SqlClient;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Migrations.Operations;
+using Xunit;
+
+namespace SeaHavenIndustries.Tests;
+
+// Shape evidence for the global Services registry migration (table,
+// indexes, FK, idempotent additive seed) plus a SQL Server execution test that
+// is silently skipped when no provider is reachable, mirroring existing
+// provider-gated migration tests.
+public class SH303ServicesRegistryMigrationTests
+{
+    private const string LocalDbMaster =
+        @"Server=(localdb)\MSSQLLocalDB;Database=master;Trusted_Connection=True;TrustServerCertificate=True;Connect Timeout=3";
+
+    [Fact]
+    public void Up_CreatesRegistryTablesUniqueIndexesFkAndIdempotentProblemSeed()
+    {
+        var operations = BuildOperations("Up");
+
+        var createTables = operations.OfType<CreateTableOperation>().ToList();
+        Assert.Equal(
+            new HashSet<string> { "Services", "ServiceWorkOrderTypes" },
+            createTables.Select(t => t.Name).ToHashSet());
+
+        var services = createTables.Single(t => t.Name == "Services");
+        Assert.Contains(services.Columns, c => c.Name == "NormalizedName" && (string)c.ColumnType! == "nvarchar(200)");
+        Assert.Contains(services.Columns, c => c.Name == "CompletionDocTemplateId" && c.IsNullable);
+        Assert.Contains(services.Columns, c => c.Name == "RequiresCompletionDocument" && !c.IsNullable);
+        Assert.Contains(services.Columns, c => c.Name == "IsActive" && !c.IsNullable);
+
+        var foreignKeys = services.ForeignKeys.Concat(
+                createTables.Single(t => t.Name == "ServiceWorkOrderTypes").ForeignKeys)
+            .ToList();
+        Assert.Contains(foreignKeys, fk =>
+            fk.Table == "Services"
+            && fk.PrincipalTable == "CompletionDocTemplates"
+            && fk.OnDelete == ReferentialAction.Restrict);
+        Assert.Contains(foreignKeys, fk =>
+            fk.Table == "ServiceWorkOrderTypes" && fk.PrincipalTable == "Services");
+
+        var indexes = operations.OfType<CreateIndexOperation>().ToList();
+        Assert.Contains(indexes, i =>
+            i.Table == "Services" && i.Columns.SequenceEqual(new[] { "NormalizedName" }) && i.IsUnique);
+        Assert.Contains(indexes, i =>
+            i.Table == "ServiceWorkOrderTypes"
+            && i.Columns.SequenceEqual(new[] { "ServiceId", "WorkOrderType" })
+            && i.IsUnique);
+
+        // The seed is raw additive SQL: read-only over DropdownOptions, idempotent
+        // via NormalizedName NOT EXISTS, and never mutates dropdown rows.
+        var seedSql = string.Join("\n", operations.OfType<SqlOperation>().Select(o => o.Sql));
+        Assert.Contains("[Category] = N'Problem'", seedSql);
+        Assert.Contains("[IsActive] = 1", seedSql);
+        Assert.Contains("NOT EXISTS", seedSql);
+        Assert.Contains("INSERT INTO [Services]", seedSql);
+        Assert.Contains("INSERT INTO [ServiceWorkOrderTypes]", seedSql);
+        Assert.DoesNotContain("UPDATE [DropdownOptions]", seedSql);
+        Assert.DoesNotContain("DELETE FROM [DropdownOptions]", seedSql);
+        Assert.DoesNotContain("DELETE [DropdownOptions]", seedSql);
+    }
+
+    [Fact]
+    public void Down_DropsRegistryTables()
+    {
+        var operations = BuildOperations("Down");
+
+        var drops = operations.OfType<DropTableOperation>().Select(d => d.Name).ToList();
+        Assert.Equal(
+            new HashSet<string> { "Services", "ServiceWorkOrderTypes" },
+            drops.ToHashSet());
+        Assert.Empty(operations.OfType<SqlOperation>());
+    }
+
+    [Fact]
+    public void SH187_Up_AddsNullableServiceLinkAndBackfillsLegacyLabels()
+    {
+        var operations = BuildOperations<SH187_WorkOrderServiceLink>("Up");
+
+        var columns = operations.OfType<AddColumnOperation>().ToList();
+        Assert.Contains(columns, c => c.Table == "workOrders" && c.Name == "ServiceId" && c.IsNullable);
+        Assert.Contains(columns, c => c.Table == "workOrders" && c.Name == "ServiceNameSnapshot"
+            && c.IsNullable && c.MaxLength == 200);
+        Assert.Contains(operations.OfType<CreateIndexOperation>(), i =>
+            i.Table == "workOrders" && i.Columns.SequenceEqual(new[] { "ServiceId" }));
+        Assert.Contains(operations.OfType<AddForeignKeyOperation>(), fk =>
+            fk.Table == "workOrders"
+            && fk.PrincipalTable == "Services"
+            && fk.OnDelete == ReferentialAction.Restrict);
+
+        var sql = string.Join("\n", operations.OfType<SqlOperation>().Select(o => o.Sql));
+        Assert.Contains("UPDATE w", sql);
+        Assert.Contains("ServiceNameSnapshot", sql);
+        Assert.Contains("LEFT JOIN [Services]", sql);
+    }
+
+    [Fact]
+    public async Task Up_SeedsActiveProblemValuesIdempotently_WhenSqlServerAvailable()
+    {
+        var masterConnectionString = await ResolveMasterConnectionStringAsync();
+        if (masterConnectionString == null)
+            return;
+
+        var dbName = $"SH303Registry_{Guid.NewGuid():N}";
+        var connectionString = WithDatabase(masterConnectionString, dbName);
+
+        try
+        {
+            await CreateDatabaseAsync(masterConnectionString, dbName);
+
+            await using var connection = new SqlConnection(connectionString);
+            await connection.OpenAsync();
+
+            await using (var seedSource = connection.CreateCommand())
+            {
+                seedSource.CommandText =
+                    """
+                    CREATE TABLE DropdownOptions (
+                        Id int NOT NULL IDENTITY PRIMARY KEY,
+                        Category nvarchar(max) NOT NULL,
+                        Value nvarchar(max) NOT NULL,
+                        ParentValue nvarchar(max) NULL,
+                        SortOrder int NOT NULL,
+                        IsActive bit NOT NULL
+                    );
+                    CREATE TABLE CompletionDocTemplates (
+                        Id int NOT NULL IDENTITY PRIMARY KEY,
+                        Name nvarchar(200) NOT NULL,
+                        ServiceKey nvarchar(max) NOT NULL,
+                        TemplateUrl nvarchar(max) NOT NULL,
+                        IsActive bit NOT NULL,
+                        IsDeleted bit NULL,
+                        createdby nvarchar(max) NULL,
+                        DeleterUserId nvarchar(max) NULL,
+                        DeletionTime datetime2 NULL,
+                        CreatedDate datetime2 NULL,
+                        LastModificationTime datetime2 NULL,
+                        LastModifierUserId int NULL
+                    );
+                    INSERT INTO DropdownOptions (Category, Value, SortOrder, IsActive) VALUES
+                        (N'Problem', N'Leak', 0, 1),
+                        (N'Problem', N'leak', 1, 1),
+                        (N'Problem', N'No Power', 2, 1),
+                        (N'Problem', N'Not Cooling', 3, 1),
+                        (N'Problem', N'Not Heating', 4, 1),
+                        (N'Problem', N'Alarm Fault', 5, 1),
+                        (N'Problem', N'Broken/Damaged', 6, 1),
+                        (N'Problem', N'Retired Ghost', 7, 0),
+                        (N'Trade', N'Electrical', 0, 1);
+                    """;
+                await seedSource.ExecuteNonQueryAsync();
+            }
+
+            await using var context = new ApplicationDbContext(
+                new DbContextOptionsBuilder<ApplicationDbContext>().UseSqlServer(connection).Options);
+            await ApplyMigrationAsync(context, new SH303_ServicesRegistry());
+
+            await using (var servicesCmd = connection.CreateCommand())
+            {
+                servicesCmd.CommandText =
+                    """
+                    SELECT [Name], [Trade], [IconKey]
+                    FROM [Services]
+                    ORDER BY [Name];
+                    """;
+                await using var reader = await servicesCmd.ExecuteReaderAsync();
+                var rows = new List<string>();
+                while (await reader.ReadAsync())
+                    rows.Add($"{reader.GetString(0)}|{reader.GetString(1)}|{reader.GetString(2)}");
+
+                // Repeated case variants collapse onto one deterministic row and the
+                // inactive value plus the non-Problem category never seed.
+                var expected = new[]
+                {
+                    "Alarm Fault|Fire & Life Safety|fire-life-safety",
+                    "Broken/Damaged|General Building & Handyman|general-building-handyman",
+                    "Leak|Plumbing & Water Systems|plumbing-water-systems",
+                    "No Power|Electrical|electrical",
+                    "Not Cooling|HVAC|hvac",
+                    "Not Heating|HVAC|hvac"
+                };
+                Assert.Equal(expected, rows.OrderBy(r => r).ToArray());
+            }
+
+            await using (var typesCmd = connection.CreateCommand())
+            {
+                typesCmd.CommandText =
+                    """
+                    SELECT COUNT(*)
+                    FROM [ServiceWorkOrderTypes] t
+                    JOIN [Services] s ON s.[Id] = t.[ServiceId]
+                    WHERE t.[WorkOrderType] IN (2, 3, 6);
+                    """;
+                Assert.Equal(18, Convert.ToInt32(await typesCmd.ExecuteScalarAsync())); // 6 services x 3 supported types
+            }
+
+            await using (var untouchedCmd = connection.CreateCommand())
+            {
+                untouchedCmd.CommandText = "SELECT COUNT(*) FROM [DropdownOptions];";
+                Assert.Equal(9, Convert.ToInt32(await untouchedCmd.ExecuteScalarAsync()));
+            }
+
+            // Re-running only the seed statements must be a no-op (idempotence).
+            var before = await CountAsync(connection, "SELECT COUNT(*) FROM [Services];");
+            await ApplySeedStatementsAsync(context);
+            var after = await CountAsync(connection, "SELECT COUNT(*) FROM [Services];");
+            Assert.Equal(before, after);
+
+            var migration = new SH303_ServicesRegistry();
+            await ApplyMigrationAsync(context, migration, "Down");
+            Assert.Equal(0, await CountAsync(connection, "SELECT COUNT(*) FROM sys.tables WHERE name IN ('Services', 'ServiceWorkOrderTypes');"));
+
+            await ApplyMigrationAsync(context, migration, "Up");
+            Assert.Equal(6, await CountAsync(connection, "SELECT COUNT(*) FROM [Services];"));
+            Assert.Equal(18, await CountAsync(connection, "SELECT COUNT(*) FROM [ServiceWorkOrderTypes];"));
+        }
+        finally
+        {
+            await DropDatabaseAsync(masterConnectionString, dbName);
+        }
+    }
+
+    private static List<MigrationOperation> BuildOperations(string direction)
+        => BuildOperations<SH303_ServicesRegistry>(direction);
+
+    private static List<MigrationOperation> BuildOperations<TMigration>(string direction)
+        where TMigration : Migration, new()
+    {
+        var builder = new MigrationBuilder("Microsoft.EntityFrameworkCore.SqlServer");
+        var operation = typeof(Migration).GetMethod(direction, BindingFlags.Instance | BindingFlags.NonPublic)
+                 ?? throw new InvalidOperationException($"Migration.{direction} not found.");
+        operation.Invoke(new TMigration(), [builder]);
+        return builder.Operations;
+    }
+
+    private static async Task ApplyMigrationAsync(ApplicationDbContext context, Migration migration, string direction = "Up")
+    {
+        var builder = new MigrationBuilder(context.Database.ProviderName!);
+        var operation = typeof(Migration).GetMethod(direction, BindingFlags.Instance | BindingFlags.NonPublic)
+                 ?? throw new InvalidOperationException($"Migration.{direction} not found.");
+        operation.Invoke(migration, [builder]);
+
+        var sqlGenerator = context.GetService<IMigrationsSqlGenerator>();
+        var commands = sqlGenerator.Generate(builder.Operations, context.Model);
+        foreach (var command in commands)
+            await context.Database.ExecuteSqlRawAsync(command.CommandText);
+    }
+
+    private static async Task ApplySeedStatementsAsync(ApplicationDbContext context)
+    {
+        var sqlOperations = BuildOperations("Up").OfType<SqlOperation>().ToList();
+        var sqlGenerator = context.GetService<IMigrationsSqlGenerator>();
+        var commands = sqlGenerator.Generate(sqlOperations, context.Model);
+        foreach (var command in commands)
+            await context.Database.ExecuteSqlRawAsync(command.CommandText);
+    }
+
+    private static async Task<int> CountAsync(SqlConnection connection, string commandText)
+    {
+        await using var command = connection.CreateCommand();
+        command.CommandText = commandText;
+        return Convert.ToInt32(await command.ExecuteScalarAsync());
+    }
+
+    private static async Task<string?> ResolveMasterConnectionStringAsync()
+    {
+        var configured = Environment.GetEnvironmentVariable("SH303_SQLSERVER_MASTER");
+        var candidate = !string.IsNullOrWhiteSpace(configured)
+            ? WithDatabase(configured, "master")
+            : OperatingSystem.IsWindows() ? LocalDbMaster : null;
+
+        if (candidate == null)
+            return null;
+
+        try
+        {
+            await using var connection = new SqlConnection(candidate);
+            await connection.OpenAsync();
+            return candidate;
+        }
+        catch (SqlException)
+        {
+            return null;
+        }
+        catch (InvalidOperationException)
+        {
+            return null;
+        }
+    }
+
+    private static async Task CreateDatabaseAsync(string masterConnectionString, string dbName)
+    {
+        await using var connection = new SqlConnection(masterConnectionString);
+        await connection.OpenAsync();
+        await using var command = connection.CreateCommand();
+        command.CommandText = $"CREATE DATABASE {QuoteSqlServerIdentifier(dbName)};";
+        await command.ExecuteNonQueryAsync();
+    }
+
+    private static async Task DropDatabaseAsync(string masterConnectionString, string dbName)
+    {
+        try
+        {
+            var quoted = QuoteSqlServerIdentifier(dbName);
+            await using var connection = new SqlConnection(masterConnectionString);
+            await connection.OpenAsync();
+            await using var command = connection.CreateCommand();
+            command.CommandText =
+                $"""
+                 IF DB_ID(@dbName) IS NOT NULL
+                 BEGIN
+                     ALTER DATABASE {quoted} SET SINGLE_USER WITH ROLLBACK IMMEDIATE;
+                     DROP DATABASE {quoted};
+                 END
+                 """;
+            command.Parameters.AddWithValue("@dbName", dbName);
+            await command.ExecuteNonQueryAsync();
+        }
+        catch
+        {
+            // Best-effort cleanup for ephemeral SQL Server databases.
+        }
+    }
+
+    private static string QuoteSqlServerIdentifier(string name) =>
+        "[" + name.Replace("]", "]]", StringComparison.Ordinal) + "]";
+
+    private static string WithDatabase(string connectionString, string database)
+    {
+        var builder = new SqlConnectionStringBuilder(connectionString)
+        {
+            InitialCatalog = database
+        };
+        return builder.ConnectionString;
+    }
+}

SeaHavenIndustries.Tests/WorkOrderAccountScopeTests.cs

@@ -835,8 +835,8 @@ public class WorkOrderAccountScopeTests
         public Task<bool> ExistsAsync(int id) => _inner.ExistsAsync(id);
         public Task<int> CountAsync() => _inner.CountAsync();
         public Task<(List<Locations> Items, int TotalCount)> GetListPagedAsync(
-            int page, int pageSize, string? search, IReadOnlyCollection<string>? states, CancellationToken cancellationToken)
-            => _inner.GetListPagedAsync(page, pageSize, search, states, cancellationToken);
+            int page, int pageSize, string? search, IReadOnlyCollection<string>? states, CancellationToken cancellationToken, string? sortBy = null, string? sortDirection = null)
+            => _inner.GetListPagedAsync(page, pageSize, search, states, cancellationToken, sortBy, sortDirection);
         public Task<Locations?> GetDetailByIdAsync(int id, CancellationToken cancellationToken)
             => _inner.GetDetailByIdAsync(id, cancellationToken);
         public Task<Locations?> GetByIdForUpdateAsync(int id, CancellationToken cancellationToken)

SeaHavenIndustries.Tests/WorkOrderBoardServiceTests.cs

@@ -1043,6 +1043,24 @@ public class WorkOrderBoardServiceTests
         Assert.Equal("09:00", dto.ApptTime);
     }
 
+    [Fact]
+    public void MapRawRow_PmEditTakesPrecedenceOverServiceSnapshot()
+    {
+        var row = RawRow(
+            scheduledDate: new DateTime(2026, 6, 23),
+            scheduledStart: null,
+            scheduledEnd: null,
+            dispatchApptDate: null) with
+        {
+            Trade = "Updated service label",
+            ServiceNameSnapshot = "Original service label"
+        };
+
+        var dto = WorkOrderBoardService.MapRawRow(row, DateTime.UtcNow);
+
+        Assert.Equal("Updated service label", dto.Pm);
+    }
+
     private static WorkOrderBoardRawRow RawRow(
         DateTime? scheduledDate,
         DateTime? scheduledStart,
@@ -1055,6 +1073,8 @@ public class WorkOrderBoardServiceTests
             CarriedOver: 0,
             IsAddOn: false,
             WorkOrderType: null,
+            ServiceId: null,
+            ServiceNameSnapshot: null,
             SiteCode: null,
             LocationName: null,
             PocName: null,