diff --git a/.env.example b/.env.example
index cb07e57..db65d8b 100644
--- a/.env.example
+++ b/.env.example
@@ -1,11 +1,11 @@
-# Sea Haven Industries — shoc-backend required configuration
+# Sea Haven Industries ÔÇö shoc-backend required configuration
 #
 # This file documents the secrets that used to be hardcoded in appsettings*.json
 # and source files. Copy the values into one of the supported configuration sources;
 # do NOT commit real values.
 #
 # .NET resolves configuration in this order (later wins):
-#   1. appsettings.json / appsettings.{Environment}.json  (committed — placeholders only)
+#   1. appsettings.json / appsettings.{Environment}.json  (committed ÔÇö placeholders only)
 #   2. User Secrets (local dev):  dotnet user-secrets set "Key:Sub" "value"
 #   3. Environment variables       (use "__" as the section separator)
 #
@@ -32,3 +32,16 @@ GoogleMaps__ApiKey=AIzaSyXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 # AWS_ACCESS_KEY_ID=
 # AWS_SECRET_ACCESS_KEY=
 # AWS_REGION=us-east-2
+
+# --- Work Order ingest (Lambda cutover) ---
+# Leave Enabled=false until ApiKey is a real secret (min 32 chars). Do not use appsettings placeholders.
+WorkOrderIngest__Enabled=false
+WorkOrderIngest__ApiKey=<shared-secret-for-X-Ingest-Key-min-32-chars>
+
+# --- Dynamo sync bridge (keep false after Lambda cutover; avoid dual-run with ingest) ---
+Sync__Enabled=true
+
+# --- Legacy endpoint deprecation headers ---
+LegacyEndpoints__DeprecationEnabled=false
+LegacyEndpoints__SunsetDate=2026-12-31
+
diff --git a/Api.SeaHavenIndustries.Tests/LocationControllerSitesTests.cs b/Api.SeaHavenIndustries.Tests/LocationControllerSitesTests.cs
new file mode 100644
index 0000000..5074c22
--- /dev/null
+++ b/Api.SeaHavenIndustries.Tests/LocationControllerSitesTests.cs
@@ -0,0 +1,109 @@
+using Api.SeaHavenIndustries.Controllers;
+using Data.SeaHavenIndustries;
+using FluentAssertions;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using Moq;
+using SeaHaven.DataServices.Implementation;
+using SeaHaven.Services.DTOs;
+using SeaHaven.Services.Implementation;
+using SeaHaven.Services.Validation;
+using Xunit;
+
+namespace Api.SeaHavenIndustries.Tests;
+
+public class LocationControllerSitesTests
+{
+    private static ApplicationDbContext NewContext()
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+        return new ApplicationDbContext(options);
+    }
+
+    private static LocationController NewController(ApplicationDbContext ctx)
+    {
+        var dataService = new LocationDataService(ctx);
+        var service = new LocationService(
+            dataService,
+            Mock.Of<ICreateLocationValidation>(),
+            Mock.Of<IUpdateLocationValidation>());
+
+        var controller = new LocationController(service, dataService)
+        {
+            ControllerContext = new ControllerContext
+            {
+                HttpContext = new DefaultHttpContext()
+            }
+        };
+
+        return controller;
+    }
+
+    private static async Task SeedSitesAsync(ApplicationDbContext ctx)
+    {
+        ctx.Locations.AddRange(
+            new Locations { Id = 1, Name = "STL8", City = "St. Louis", State = "MO" },
+            new Locations { Id = 2, Name = "BK5", City = "Dallas", State = "TX" },
+            new Locations { Id = 3, Name = "IND9", City = "Indianapolis", State = "IN" },
+            new Locations { Id = 4, Name = "DFW8", City = "Dallas", State = "TX" });
+        await ctx.SaveChangesAsync();
+    }
+
+    [Fact]
+    public async Task GetSites_ReturnsIdCodeCityState_OrderedByCode()
+    {
+        await using var ctx = NewContext();
+        await SeedSitesAsync(ctx);
+        var controller = NewController(ctx);
+
+        var result = await controller.GetSites();
+
+        var ok = result.Should().BeOfType<OkObjectResult>().Subject;
+        var data = ok.Value.Should().BeAssignableTo<IReadOnlyList<SiteOptionDTO>>().Subject;
+
+        data.Should().HaveCount(4);
+        data.Select(s => s.Code).Should().ContainInOrder("BK5", "DFW8", "IND9", "STL8");
+        data[0].Should().BeEquivalentTo(new SiteOptionDTO
+        {
+            Id = 2,
+            Code = "BK5",
+            City = "Dallas",
+            State = "TX"
+        });
+    }
+
+    [Fact]
+    public async Task GetSites_FiltersByCode()
+    {
+        await using var ctx = NewContext();
+        await SeedSitesAsync(ctx);
+        var controller = NewController(ctx);
+
+        var result = await controller.GetSites("bk5");
+
+        var ok = result.Should().BeOfType<OkObjectResult>().Subject;
+        var data = ok.Value.Should().BeAssignableTo<IReadOnlyList<SiteOptionDTO>>().Subject;
+
+        data.Should().ContainSingle();
+        data[0].Code.Should().Be("BK5");
+    }
+
+    [Fact]
+    public async Task GetSites_FiltersByCity()
+    {
+        await using var ctx = NewContext();
+        await SeedSitesAsync(ctx);
+        var controller = NewController(ctx);
+
+        var result = await controller.GetSites("Dallas");
+
+        var ok = result.Should().BeOfType<OkObjectResult>().Subject;
+        var data = ok.Value.Should().BeAssignableTo<IReadOnlyList<SiteOptionDTO>>().Subject;
+
+        data.Should().HaveCount(2);
+        data.Select(s => s.Code).Should().BeEquivalentTo("BK5", "DFW8");
+    }
+}
diff --git a/Api.SeaHavenIndustries.Tests/WorkOrderControllerSearchTests.cs b/Api.SeaHavenIndustries.Tests/WorkOrderControllerSearchTests.cs
new file mode 100644
index 0000000..ef2ac67
--- /dev/null
+++ b/Api.SeaHavenIndustries.Tests/WorkOrderControllerSearchTests.cs
@@ -0,0 +1,163 @@
+using Api.SeaHavenIndustries.Controllers;
+using Api.SeaHavenIndustries.DTOs;
+using Data.SeaHavenIndustries;
+using FluentAssertions;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Configuration;
+using Moq;
+using SeaHaven.DataServices.Implementation;
+using SeaHaven.DataServices.Interfaces;
+using SeaHaven.Services.DTOs;
+using SeaHaven.Services.Helpers;
+using SeaHaven.Services.Implementation;
+using SeaHaven.Services.Interfaces;
+using Xunit;
+
+namespace Api.SeaHavenIndustries.Tests;
+
+public class WorkOrderControllerSearchTests
+{
+    private static ApplicationDbContext NewContext()
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+        return new ApplicationDbContext(options);
+    }
+
+    private static UserManager<ApplicationUser> MockUserManager()
+    {
+        var store = new Mock<IUserStore<ApplicationUser>>();
+        return new Mock<UserManager<ApplicationUser>>(
+            store.Object, null!, null!, null!, null!, null!, null!, null!, null!).Object;
+    }
+
+    private static WorkOrderController NewController(
+        ApplicationDbContext ctx,
+        IWorkOrderAdvancedSearchService advancedSearch)
+    {
+        var controller = new WorkOrderController(
+            MockUserManager(),
+            Mock.Of<IWorkOrderService>(),
+            Mock.Of<IWorkOrderDataService>(),
+            Mock.Of<ICommentDataService>(),
+            Mock.Of<IQuotesDataService>(),
+            Mock.Of<IUserDataService>(),
+            Mock.Of<IDispatchDataService>(),
+            Mock.Of<IVendorDataService>(),
+            Mock.Of<ITaskListTemplateDataService>(),
+            ctx,
+            Mock.Of<IWebHostEnvironment>(),
+            Mock.Of<IHttpContextAccessor>(),
+            null!,
+            null!,
+            Mock.Of<IConfiguration>(),
+            Mock.Of<IWorkOrderBoardService>(),
+            Mock.Of<IWorkOrderBoardUpdateService>(),
+            Mock.Of<IWorkOrderBoardCreateService>(),
+            Mock.Of<IWorkOrderBoardCancelService>(),
+            advancedSearch,
+            Mock.Of<IWorkOrderDetailService>(),
+            Mock.Of<IWorkOrderCommentService>(),
+            Mock.Of<IWorkOrderCompletionService>(),
+            Mock.Of<IWorkOrderMediaService>());
+
+        controller.ControllerContext = new ControllerContext
+        {
+            HttpContext = new DefaultHttpContext
+            {
+                User = new System.Security.Claims.ClaimsPrincipal(
+                    new System.Security.Claims.ClaimsIdentity(
+                        new[]
+                        {
+                            new System.Security.Claims.Claim(
+                                System.Security.Claims.ClaimTypes.NameIdentifier,
+                                "test-user")
+                        },
+                        "Test"))
+            }
+        };
+
+        return controller;
+    }
+
+    [Fact]
+    public async Task SearchBoard_WhenCustomPresetMissingDates_ReturnsBadRequest()
+    {
+        using var ctx = NewContext();
+        var advancedSearch = new WorkOrderAdvancedSearchService(
+            Mock.Of<IWorkOrderAdvancedSearchDataService>());
+        var controller = NewController(ctx, advancedSearch);
+
+        var result = await controller.SearchBoard(new WorkOrderAdvancedSearchQueryDto
+        {
+            DatePreset = WorkOrderAdvancedSearchDatePreset.Custom
+        });
+
+        var badRequest = result.Should().BeOfType<BadRequestObjectResult>().Subject;
+        var body = badRequest.Value.Should().BeOfType<Response>().Subject;
+        body.Status.Should().Be("Error");
+        body.Message.Should().Contain("dateFrom");
+    }
+
+    [Fact]
+    public async Task GetBoard_WhenWeekEndBeforeWeekStart_ReturnsBadRequest()
+    {
+        using var ctx = NewContext();
+        var boardService = new WorkOrderBoardService(new WorkOrderBoardDataService(ctx));
+        var controller = NewController(ctx, Mock.Of<IWorkOrderAdvancedSearchService>());
+        // Replace board service - controller uses injected mock. Need different approach.
+
+        // Use real board service via manual controller setup
+        var advancedSearch = Mock.Of<IWorkOrderAdvancedSearchService>();
+        var controllerWithBoard = new WorkOrderController(
+            MockUserManager(),
+            Mock.Of<IWorkOrderService>(),
+            Mock.Of<IWorkOrderDataService>(),
+            Mock.Of<ICommentDataService>(),
+            Mock.Of<IQuotesDataService>(),
+            Mock.Of<IUserDataService>(),
+            Mock.Of<IDispatchDataService>(),
+            Mock.Of<IVendorDataService>(),
+            Mock.Of<ITaskListTemplateDataService>(),
+            ctx,
+            Mock.Of<IWebHostEnvironment>(),
+            Mock.Of<IHttpContextAccessor>(),
+            null!,
+            null!,
+            Mock.Of<IConfiguration>(),
+            boardService,
+            Mock.Of<IWorkOrderBoardUpdateService>(),
+            Mock.Of<IWorkOrderBoardCreateService>(),
+            Mock.Of<IWorkOrderBoardCancelService>(),
+            advancedSearch,
+            Mock.Of<IWorkOrderDetailService>(),
+            Mock.Of<IWorkOrderCommentService>(),
+            Mock.Of<IWorkOrderCompletionService>(),
+            Mock.Of<IWorkOrderMediaService>());
+
+        controllerWithBoard.ControllerContext = new ControllerContext
+        {
+            HttpContext = new DefaultHttpContext
+            {
+                User = new System.Security.Claims.ClaimsPrincipal(
+                    new System.Security.Claims.ClaimsIdentity(
+                        new[] { new System.Security.Claims.Claim(System.Security.Claims.ClaimTypes.NameIdentifier, "test-user") },
+                        "Test"))
+            }
+        };
+
+        var result = await controllerWithBoard.GetBoard(
+            new DateOnly(2026, 6, 22),
+            new DateOnly(2026, 6, 15));
+
+        var badRequest = result.Should().BeOfType<BadRequestObjectResult>().Subject;
+        var body = badRequest.Value.Should().BeOfType<Response>().Subject;
+        body.Status.Should().Be("Error");
+        body.Message.Should().Contain("weekEnd");
+    }
+}
diff --git a/Api.SeaHavenIndustries/Controllers/LocationController.cs b/Api.SeaHavenIndustries/Controllers/LocationController.cs
index 4bfba79..3d671b2 100644
--- a/Api.SeaHavenIndustries/Controllers/LocationController.cs
+++ b/Api.SeaHavenIndustries/Controllers/LocationController.cs
@@ -26,6 +26,13 @@ namespace Api.SeaHavenIndustries.Controllers
             _locationDataService = locationDataService;
         }
 
+        [HttpGet("sites")]
+        public async Task<IActionResult> GetSites(string? search = null)
+        {
+            var data = await _locationService.GetSiteOptionsAsync(search);
+            return Ok(data);
+        }
+
         [HttpGet("GetLocationList")]
         public async Task<IActionResult> GetLocationList(string? search = "", int page = 1, int pageSize = 10)
         {
diff --git a/Api.SeaHavenIndustries/Controllers/SyncController.cs b/Api.SeaHavenIndustries/Controllers/SyncController.cs
index 5d7f778..d246273 100644
--- a/Api.SeaHavenIndustries/Controllers/SyncController.cs
+++ b/Api.SeaHavenIndustries/Controllers/SyncController.cs
@@ -1,32 +1,49 @@
 using Amazon.DynamoDBv2;
 using Amazon.DynamoDBv2.Model;
+using Api.SeaHavenIndustries.Options;
 using Data.SeaHavenIndustries;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Options;
 
 namespace Api.SeaHavenIndustries.Controllers
 {
-    [Authorize]
+    [Authorize(Roles = "Admin")]
     [ApiController]
     [Route("api/[controller]")]
     public class SyncController : Controller
     {
         private readonly ApplicationDbContext _db;
         private readonly AmazonDynamoDBClient _dynamo;
+        private readonly SyncOptions _syncOptions;
         private const string WO_TABLE = "WorkOrders";
         private const string COMMENTS_TABLE = "WorkOrderComments";
         private const string VENDOR_REPLIES_TABLE = "VendorReplies";
 
-        public SyncController(ApplicationDbContext db)
+        public SyncController(ApplicationDbContext db, IOptions<SyncOptions> syncOptions)
         {
             _db = db;
+            _syncOptions = syncOptions.Value;
             _dynamo = new AmazonDynamoDBClient(Amazon.RegionEndpoint.USEast1);
         }
 
+        private IActionResult? SyncDisabledResult()
+        {
+            if (_syncOptions.Enabled)
+                return null;
+
+            return StatusCode(StatusCodes.Status503ServiceUnavailable, new
+            {
+                message = "DynamoDB sync bridge is disabled. Use POST /api/workorders/ingest."
+            });
+        }
+
         [HttpPost("WorkOrders")]
         public async Task<IActionResult> SyncWorkOrders()
         {
+            if (SyncDisabledResult() is { } disabled)
+                return disabled;
             var synced = 0;
             var created = 0;
             var updated = 0;
@@ -62,12 +79,12 @@ namespace Api.SeaHavenIndustries.Controllers
                     var existing = await _db.workOrders
                         .FirstOrDefaultAsync(w => w.ExternalWorkOrderId == externalId);
 
-                    var locationId = await ResolveLocationId(
+                    var (locationId, locationWasCreated) = await ResolveLocationId(
                         GetString(item, "site_code"),
                         GetString(item, "building"),
                         GetString(item, "address"));
 
-                    if (locationId.HasValue && !locationsCreated.Equals(0))
+                    if (locationWasCreated)
                         locationsCreated++;
 
                     if (existing == null)
@@ -138,6 +155,9 @@ namespace Api.SeaHavenIndustries.Controllers
         [HttpPost("Comments")]
         public async Task<IActionResult> SyncComments()
         {
+            if (SyncDisabledResult() is { } disabled)
+                return disabled;
+
             var synced = 0;
             var created = 0;
             var skipped = 0;
@@ -212,6 +232,9 @@ namespace Api.SeaHavenIndustries.Controllers
         [HttpPost("BackfillInternalWONumbers")]
         public async Task<IActionResult> BackfillInternalWONumbers()
         {
+            if (SyncDisabledResult() is { } disabled)
+                return disabled;
+
             var wosMissing = await _db.workOrders
                 .Where(w => w.InternalWONumber == null || w.InternalWONumber == "")
                 .OrderBy(w => w.Id)
@@ -243,6 +266,9 @@ namespace Api.SeaHavenIndustries.Controllers
         [HttpPost("BackfillDispatchNumbers")]
         public async Task<IActionResult> BackfillDispatchNumbers()
         {
+            if (SyncDisabledResult() is { } disabled)
+                return disabled;
+
             var missing = await _db.Dispatches
                 .Where(d => d.DispatchNumber == null || d.DispatchNumber == "")
                 .OrderBy(d => d.Id)
@@ -270,6 +296,9 @@ namespace Api.SeaHavenIndustries.Controllers
         [HttpPost("VendorReplies")]
         public async Task<IActionResult> SyncVendorReplies()
         {
+            if (SyncDisabledResult() is { } disabled)
+                return disabled;
+
             var synced = 0;
             var created = 0;
             var skipped = 0;
@@ -341,6 +370,9 @@ namespace Api.SeaHavenIndustries.Controllers
         [HttpPost("BackfillCommentTypes")]
         public async Task<IActionResult> BackfillCommentTypes()
         {
+            if (SyncDisabledResult() is { } disabled)
+                return disabled;
+
             var updated = await _db.Database.ExecuteSqlRawAsync(
                 "UPDATE Comments SET CommentType = 'customer' WHERE ExternalCommentId IS NOT NULL AND (CommentType IS NULL OR CommentType = '')");
             return Ok(new { updated });
@@ -349,6 +381,9 @@ namespace Api.SeaHavenIndustries.Controllers
         [HttpPost("All")]
         public async Task<IActionResult> SyncAll()
         {
+            if (SyncDisabledResult() is { } disabled)
+                return disabled;
+
             var woResult = await SyncWorkOrders() as OkObjectResult;
             var commentResult = await SyncComments() as OkObjectResult;
 
@@ -359,17 +394,17 @@ namespace Api.SeaHavenIndustries.Controllers
             });
         }
 
-        private async Task<int?> ResolveLocationId(string? siteCode, string? building, string? address)
+        private async Task<(int? LocationId, bool Created)> ResolveLocationId(string? siteCode, string? building, string? address)
         {
             if (string.IsNullOrWhiteSpace(siteCode) && string.IsNullOrWhiteSpace(building))
-                return null;
+                return (null, false);
 
             var matchCode = siteCode ?? building;
             var existing = await _db.Locations
                 .FirstOrDefaultAsync(l => l.Name == matchCode || l.Title == matchCode);
 
             if (existing != null)
-                return existing.Id;
+                return (existing.Id, false);
 
             var location = new Locations
             {
@@ -382,7 +417,7 @@ namespace Api.SeaHavenIndustries.Controllers
             _db.Locations.Add(location);
             await _db.SaveChangesAsync();
 
-            return location.Id;
+            return (location.Id, true);
         }
 
         private static string? GetString(Dictionary<string, AttributeValue> item, string key)
diff --git a/Api.SeaHavenIndustries/Controllers/VendorController.cs b/Api.SeaHavenIndustries/Controllers/VendorController.cs
index 9f6afc7..9c25ceb 100644
--- a/Api.SeaHavenIndustries/Controllers/VendorController.cs
+++ b/Api.SeaHavenIndustries/Controllers/VendorController.cs
@@ -174,6 +174,7 @@ namespace Api.SeaHavenIndustries.Controllers
                 {
                     v.Id,
                     v.CompanyName,
+                    v.ContactName,
                     v.TradeSpecialties,
                     v.Address,
                     v.City,
@@ -191,6 +192,7 @@ namespace Api.SeaHavenIndustries.Controllers
                 {
                     v.Id,
                     v.CompanyName,
+                    v.ContactName,
                     v.TradeSpecialties,
                     address = string.Join(", ", addr),
                     distanceMiles = distance.HasValue ? Math.Round(distance.Value, 1) : (double?)null
diff --git a/Api.SeaHavenIndustries/Controllers/WorkOrderController.cs b/Api.SeaHavenIndustries/Controllers/WorkOrderController.cs
index 57eb4b8..cedc42f 100644
--- a/Api.SeaHavenIndustries/Controllers/WorkOrderController.cs
+++ b/Api.SeaHavenIndustries/Controllers/WorkOrderController.cs
@@ -17,11 +17,12 @@ using System.Security.Claims;
 using static System.Runtime.InteropServices.JavaScript.JSType;
 using SeaHaven.Services.Interfaces;
 using SeaHaven.Services.DTOs;
+using SeaHaven.Services.Exceptions;
 using SeaHaven.DataServices.Interfaces;
 
 namespace Api.SeaHavenIndustries.Controllers
 {
-   // [Authorize]
+    [Authorize]
     [ApiController]
     [Route("api/WorkOrder")]
     [Route("api/workorders")]
@@ -42,6 +43,15 @@ namespace Api.SeaHavenIndustries.Controllers
         private readonly Helper.SendMessage _sendMessage;
         private readonly Helper.VendorPortalTokenService _vendorTokens;
         private readonly IConfiguration _config;
+        private readonly IWorkOrderBoardService _workOrderBoardService;
+        private readonly IWorkOrderBoardUpdateService _boardUpdateService;
+        private readonly IWorkOrderBoardCreateService _boardCreateService;
+        private readonly IWorkOrderBoardCancelService _boardCancelService;
+        private readonly IWorkOrderAdvancedSearchService _advancedSearchService;
+        private readonly IWorkOrderDetailService _workOrderDetailService;
+        private readonly IWorkOrderCommentService _workOrderCommentService;
+        private readonly IWorkOrderCompletionService _workOrderCompletionService;
+        private readonly IWorkOrderMediaService _workOrderMediaService;
 
         public WorkOrderController(
             UserManager<ApplicationUser> userManager,
@@ -58,7 +68,16 @@ namespace Api.SeaHavenIndustries.Controllers
             IHttpContextAccessor httpContext,
             Helper.SendMessage sendMessage,
             Helper.VendorPortalTokenService vendorTokens,
-            IConfiguration config)
+            IConfiguration config,
+            IWorkOrderBoardService workOrderBoardService,
+            IWorkOrderBoardUpdateService boardUpdateService,
+            IWorkOrderBoardCreateService boardCreateService,
+            IWorkOrderBoardCancelService boardCancelService,
+            IWorkOrderAdvancedSearchService advancedSearchService,
+            IWorkOrderDetailService workOrderDetailService,
+            IWorkOrderCommentService workOrderCommentService,
+            IWorkOrderCompletionService workOrderCompletionService,
+            IWorkOrderMediaService workOrderMediaService)
         {
             _userManager = userManager;
             _workOrderService = workOrderService;
@@ -75,7 +94,390 @@ namespace Api.SeaHavenIndustries.Controllers
             _sendMessage = sendMessage;
             _vendorTokens = vendorTokens;
             _config = config;
+            _workOrderBoardService = workOrderBoardService;
+            _boardUpdateService = boardUpdateService;
+            _boardCreateService = boardCreateService;
+            _boardCancelService = boardCancelService;
+            _advancedSearchService = advancedSearchService;
+            _workOrderDetailService = workOrderDetailService;
+            _workOrderCommentService = workOrderCommentService;
+            _workOrderCompletionService = workOrderCompletionService;
+            _workOrderMediaService = workOrderMediaService;
         }
+
+        [HttpGet("board")]
+        public async Task<IActionResult> GetBoard(
+            [FromQuery] DateOnly weekStart,
+            [FromQuery] DateOnly? weekEnd = null,
+            [FromQuery] List<string>? dispatchers = null,
+            [FromQuery] bool myWorkOrders = false,
+            [FromQuery] List<WorkOrderType>? types = null,
+            [FromQuery] string? search = null)
+        {
+            try
+            {
+                var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
+                var query = new WorkOrderBoardQueryDto
+                {
+                    WeekStart = weekStart,
+                    WeekEnd = weekEnd,
+                    Dispatchers = dispatchers,
+                    MyWorkOrders = myWorkOrders,
+                    Types = types,
+                    Search = search
+                };
+
+                var result = await _workOrderBoardService.GetBoardAsync(query, userId);
+                return Ok(result);
+            }
+            catch (ArgumentException ex)
+            {
+                return BadRequest(new Response { Status = "Error", Message = ex.Message });
+            }
+        }
+
+        [HttpGet("board/search")]
+        public async Task<IActionResult> SearchBoard([FromQuery] WorkOrderAdvancedSearchQueryDto query)
+        {
+            try
+            {
+                var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
+                var result = await _advancedSearchService.SearchAsync(query, userId);
+                return Ok(result);
+            }
+            catch (ArgumentException ex)
+            {
+                return BadRequest(new Response { Status = "Error", Message = ex.Message });
+            }
+        }
+
+        [HttpGet("lookups/dispatchers")]
+        public async Task<IActionResult> GetDispatcherLookups()
+        {
+            var result = await _workOrderBoardService.GetDispatcherLookupsAsync();
+            return Ok(result);
+        }
+
+        [HttpPatch("{id:int}/board")]
+        public async Task<IActionResult> PatchBoardField(int id, [FromBody] WorkOrderBoardPatchRequestDto request)
+        {
+            try
+            {
+                var actorId = User.FindFirstValue(ClaimTypes.NameIdentifier);
+                var row = await _boardUpdateService.PatchFieldAsync(id, request, actorId);
+                return Ok(row);
+            }
+            catch (WorkOrderBoardConcurrencyException ex)
+            {
+                return Conflict(new WorkOrderBoardConflictDto
+                {
+                    CurrentState = ex.CurrentState
+                });
+            }
+            catch (WorkOrderBoardValidationException ex)
+            {
+                return UnprocessableEntity(new WorkOrderBoardValidationErrorDto
+                {
+                    Code = ex.Code,
+                    Message = ex.Message
+                });
+            }
+            catch (ArgumentException ex)
+            {
+                return BadRequest(new Response { Status = "Error", Message = ex.Message });
+            }
+        }
+
+        [HttpPost("board")]
+        public async Task<IActionResult> CreateBoardWorkOrder([FromBody] WorkOrderBoardCreateRequestDto request)
+        {
+            try
+            {
+                var actorId = User.FindFirstValue(ClaimTypes.NameIdentifier);
+                var row = await _boardCreateService.CreateAsync(request, actorId);
+                return Ok(row);
+            }
+            catch (ValidationException vex)
+            {
+                var errors = string.Join(", ", vex.Errors.Select(e => e.ErrorMessage));
+                return BadRequest(new Response { Status = "Validation Error", Message = errors });
+            }
+            catch (WorkOrderBoardValidationException ex) when (ex.Code == "DuplicateWoNumber")
+            {
+                return Conflict(new WorkOrderBoardValidationErrorDto
+                {
+                    Code = ex.Code,
+                    Message = ex.Message
+                });
+            }
+            catch (WorkOrderBoardValidationException ex)
+            {
+                return UnprocessableEntity(new WorkOrderBoardValidationErrorDto
+                {
+                    Code = ex.Code,
+                    Message = ex.Message
+                });
+            }
+        }
+
+        [HttpPost("{id:int}/cancel")]
+        public async Task<IActionResult> CancelBoardWorkOrder(int id)
+        {
+            try
+            {
+                var actorId = User.FindFirstValue(ClaimTypes.NameIdentifier);
+                var row = await _boardCancelService.CancelAsync(id, actorId);
+                return Ok(row);
+            }
+            catch (WorkOrderBoardValidationException ex)
+            {
+                return UnprocessableEntity(new WorkOrderBoardValidationErrorDto
+                {
+                    Code = ex.Code,
+                    Message = ex.Message
+                });
+            }
+        }
+
+        [HttpGet("{id:int}/detail")]
+        public async Task<IActionResult> GetDetail(int id)
+        {
+            var detail = await _workOrderDetailService.GetDetailAsync(id);
+            if (detail == null)
+                return NotFound(new Response { Status = "Error", Message = "Work order not found." });
+            return Ok(detail);
+        }
+
+        [HttpGet("{id:int}/audit")]
+        public async Task<IActionResult> GetAudit(int id, [FromQuery] int limit = 50)
+        {
+            var audit = await _workOrderDetailService.GetAuditAsync(id, limit);
+            if (audit == null)
+                return NotFound(new Response { Status = "Error", Message = "Work order not found." });
+            return Ok(audit);
+        }
+
+        [HttpGet("{id:int}/comments")]
+        public async Task<IActionResult> GetBoardComments(int id)
+        {
+            var comments = await _workOrderCommentService.GetCommentsAsync(id);
+            if (comments == null)
+                return NotFound(new Response { Status = "Error", Message = "Work order not found." });
+            return Ok(comments);
+        }
+
+        [HttpPost("{id:int}/comments")]
+        public async Task<IActionResult> AddBoardComment(int id, [FromBody] WorkOrderCommentCreateDto request)
+        {
+            try
+            {
+                var actorId = User.FindFirstValue(ClaimTypes.NameIdentifier);
+                var comment = await _workOrderCommentService.AddCommentAsync(id, request, actorId);
+                return Ok(comment);
+            }
+            catch (WorkOrderBoardValidationException ex) when (ex.Code == "NotFound")
+            {
+                return NotFound(new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
+            }
+            catch (WorkOrderBoardValidationException ex)
+            {
+                return UnprocessableEntity(new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
+            }
+        }
+
+        [HttpPatch("{id:int}/comments/{commentId:int}")]
+        public async Task<IActionResult> UpdateBoardComment(
+            int id,
+            int commentId,
+            [FromBody] WorkOrderCommentCreateDto request)
+        {
+            try
+            {
+                var actorId = User.FindFirstValue(ClaimTypes.NameIdentifier);
+                var isAdmin = User.IsInRole("Admin");
+                var comment = await _workOrderCommentService.UpdateCommentAsync(
+                    id, commentId, request, actorId, isAdmin);
+                return Ok(comment);
+            }
+            catch (WorkOrderBoardValidationException ex) when (ex.Code == "NotFound")
+            {
+                return NotFound(new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
+            }
+            catch (WorkOrderBoardValidationException ex) when (ex.Code == "Forbidden")
+            {
+                return StatusCode(StatusCodes.Status403Forbidden,
+                    new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
+            }
+            catch (WorkOrderBoardValidationException ex)
+            {
+                return UnprocessableEntity(new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
+            }
+        }
+
+        [HttpGet("completion-templates")]
+        public async Task<IActionResult> GetCompletionTemplates(
+            [FromQuery] string? serviceKey = null,
+            [FromQuery] WorkOrderType? workOrderType = null)
+        {
+            var templates = await _workOrderCompletionService.GetTemplatesAsync(serviceKey, workOrderType);
+            return Ok(templates);
+        }
+
+        [HttpGet("completion-templates/{id:int}")]
+        public async Task<IActionResult> GetCompletionTemplate(int id)
+        {
+            var template = await _workOrderCompletionService.GetTemplateByIdAsync(id);
+            if (template == null)
+                return NotFound(new Response { Status = "Error", Message = "Template not found." });
+            return Ok(template);
+        }
+
+        [Authorize(Roles = "Admin")]
+        [HttpPost("completion-templates")]
+        public async Task<IActionResult> CreateCompletionTemplate([FromBody] CompletionDocTemplateCreateDto request)
+        {
+            try
+            {
+                var created = await _workOrderCompletionService.CreateTemplateAsync(request);
+                return Ok(created);
+            }
+            catch (WorkOrderBoardValidationException ex)
+            {
+                return UnprocessableEntity(new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
+            }
+        }
+
+        [Authorize(Roles = "Admin")]
+        [HttpPut("completion-templates/{id:int}")]
+        public async Task<IActionResult> UpdateCompletionTemplate(int id, [FromBody] CompletionDocTemplateCreateDto request)
+        {
+            try
+            {
+                var updated = await _workOrderCompletionService.UpdateTemplateAsync(id, request);
+                return Ok(updated);
+            }
+            catch (WorkOrderBoardValidationException ex) when (ex.Code == "NotFound")
+            {
+                return NotFound(new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
+            }
+            catch (WorkOrderBoardValidationException ex)
+            {
+                return UnprocessableEntity(new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
+            }
+        }
+
+        [Authorize(Roles = "Admin")]
+        [HttpDelete("completion-templates/{id:int}")]
+        public async Task<IActionResult> DeleteCompletionTemplate(int id)
+        {
+            try
+            {
+                await _workOrderCompletionService.DeleteTemplateAsync(id);
+                return NoContent();
+            }
+            catch (WorkOrderBoardValidationException ex) when (ex.Code == "NotFound")
+            {
+                return NotFound(new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
+            }
+        }
+
+        [HttpPost("{id:int}/completion-doc")]
+        [RequestSizeLimit(30_000_000)]
+        public async Task<IActionResult> UploadCompletionDoc(
+            int id,
+            [FromForm] IFormFile file,
+            [FromForm] string? signOffName = null,
+            [FromForm] string? signOffSignature = null,
+            [FromForm] string? workOrderVersion = null)
+        {
+            if (file == null || file.Length == 0)
+                return BadRequest(new Response { Status = "Error", Message = "file is required." });
+
+            try
+            {
+                var actorId = User.FindFirstValue(ClaimTypes.NameIdentifier);
+                var fileUrl = await SaveFileAsync(file);
+                var result = await _workOrderCompletionService.UploadCompletionDocAsync(
+                    id,
+                    new WorkOrderCompletionDocUploadDto
+                    {
+                        SignOffName = signOffName,
+                        SignOffSignature = signOffSignature,
+                        WorkOrderVersion = workOrderVersion
+                    },
+                    fileUrl,
+                    actorId);
+                return Ok(result);
+            }
+            catch (WorkOrderBoardValidationException ex) when (ex.Code is "NotFound")
+            {
+                return NotFound(new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
+            }
+            catch (WorkOrderBoardValidationException ex) when (ex.Code is "ConcurrencyConflict")
+            {
+                return Conflict(new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
+            }
+            catch (WorkOrderBoardValidationException ex)
+            {
+                return UnprocessableEntity(new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
+            }
+        }
+
+        [HttpGet("{id:int}/media")]
+        public async Task<IActionResult> GetMedia(int id)
+        {
+            var media = await _workOrderMediaService.GetMediaAsync(id);
+            if (media == null)
+                return NotFound(new Response { Status = "Error", Message = "Work order not found." });
+            return Ok(media);
+        }
+
+        [HttpPost("{id:int}/media")]
+        [RequestSizeLimit(30_000_000)]
+        public async Task<IActionResult> AddMedia(
+            int id,
+            [FromForm] WorkOrderMediaCategory category,
+            [FromForm] IFormFile file)
+        {
+            if (file == null || file.Length == 0)
+                return BadRequest(new Response { Status = "Error", Message = "file is required." });
+
+            try
+            {
+                var actorId = User.FindFirstValue(ClaimTypes.NameIdentifier);
+                var fileUrl = await SaveFileAsync(file);
+                var media = await _workOrderMediaService.AddMediaAsync(id, category, fileUrl, actorId);
+                return Ok(media);
+            }
+            catch (WorkOrderBoardValidationException ex) when (ex.Code == "NotFound")
+            {
+                return NotFound(new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
+            }
+            catch (WorkOrderBoardValidationException ex)
+            {
+                return UnprocessableEntity(new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
+            }
+        }
+
+        [HttpDelete("{id:int}/media/{mediaId:int}")]
+        public async Task<IActionResult> DeleteMedia(int id, int mediaId)
+        {
+            try
+            {
+                var actorId = User.FindFirstValue(ClaimTypes.NameIdentifier);
+                await _workOrderMediaService.DeleteMediaAsync(id, mediaId, actorId);
+                return NoContent();
+            }
+            catch (WorkOrderBoardValidationException ex) when (ex.Code == "NotFound")
+            {
+                return NotFound(new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
+            }
+            catch (WorkOrderBoardValidationException ex)
+            {
+                return UnprocessableEntity(new WorkOrderBoardValidationErrorDto { Code = ex.Code, Message = ex.Message });
+            }
+        }
+
         [HttpPost]
         [Route("AddWorkorder")]
         public async Task<IActionResult> Addworkorder([FromForm] Workorder_DTO model)
@@ -295,6 +697,7 @@ namespace Api.SeaHavenIndustries.Controllers
         }
 
 
+        [Authorize(Roles = "Admin")]
         [HttpDelete]
         [Route("DeleteWorkorder")]
         public async Task<IActionResult> Deleteworkorder([FromBody] EditWorkorder_DTO model)
diff --git a/Api.SeaHavenIndustries/Controllers/WorkOrderIngestController.cs b/Api.SeaHavenIndustries/Controllers/WorkOrderIngestController.cs
new file mode 100644
index 0000000..47b91a1
--- /dev/null
+++ b/Api.SeaHavenIndustries/Controllers/WorkOrderIngestController.cs
@@ -0,0 +1,50 @@
+using Api.SeaHavenIndustries.Filters;
+using Microsoft.AspNetCore.Mvc;
+using SeaHaven.Services.DTOs;
+using SeaHaven.Services.Interfaces;
+
+namespace Api.SeaHavenIndustries.Controllers
+{
+    [ApiController]
+    [Route("api/workorders")]
+    public class WorkOrderIngestController : ControllerBase
+    {
+        private const int MaxBatchSize = 100;
+        private readonly IWorkOrderIngestService _ingestService;
+
+        public WorkOrderIngestController(IWorkOrderIngestService ingestService)
+        {
+            _ingestService = ingestService;
+        }
+
+        /// <summary>
+        /// Idempotent upsert by ExternalWorkOrderId (Lambda cutover target).
+        /// Auth: X-Ingest-Key header.
+        /// </summary>
+        [HttpPost("ingest")]
+        [IngestApiKey]
+        [ProducesResponseType(typeof(WorkOrderIngestBatchResultDto), StatusCodes.Status200OK)]
+        public async Task<ActionResult<WorkOrderIngestBatchResultDto>> Ingest(
+            [FromBody] WorkOrderIngestBatchRequestDto? batch,
+            CancellationToken cancellationToken)
+        {
+            var items = NormalizeItems(batch);
+            if (items.Count == 0)
+                return BadRequest("At least one item with externalWorkOrderId is required.");
+
+            if (items.Count > MaxBatchSize)
+                return BadRequest($"Max {MaxBatchSize} items per request.");
+
+            var result = await _ingestService.UpsertBatchAsync(items, cancellationToken);
+            return Ok(result);
+        }
+
+        private static List<WorkOrderIngestPayloadDto> NormalizeItems(WorkOrderIngestBatchRequestDto? batch)
+        {
+            if (batch?.Items is { Count: > 0 })
+                return batch.Items;
+
+            return new List<WorkOrderIngestPayloadDto>();
+        }
+    }
+}
diff --git a/Api.SeaHavenIndustries/Controllers/WorkOrderJobsController.cs b/Api.SeaHavenIndustries/Controllers/WorkOrderJobsController.cs
new file mode 100644
index 0000000..4277475
--- /dev/null
+++ b/Api.SeaHavenIndustries/Controllers/WorkOrderJobsController.cs
@@ -0,0 +1,58 @@
+using Api.SeaHavenIndustries.Options;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using SeaHaven.Services.DTOs;
+using SeaHaven.Services.Helpers;
+using SeaHaven.Services.Interfaces;
+
+namespace Api.SeaHavenIndustries.Controllers
+{
+    /// <summary>Ops-only endpoints for manual domain job reprocessing.</summary>
+    [Authorize(Roles = "Admin")]
+    [ApiController]
+    [Route("api/workorders/jobs")]
+    public class WorkOrderJobsController : ControllerBase
+    {
+        private readonly IWorkOrderWeekRolledService _weekRolledService;
+        private readonly IPastDueCacheService _pastDueCacheService;
+
+        public WorkOrderJobsController(
+            IWorkOrderWeekRolledService weekRolledService,
+            IPastDueCacheService pastDueCacheService)
+        {
+            _weekRolledService = weekRolledService;
+            _pastDueCacheService = pastDueCacheService;
+        }
+
+        /// <summary>
+        /// Reprocess WeekRolled for a specific operational week (Monday start).
+        /// Idempotent via WorkOrderWeekRolledLedger.
+        /// </summary>
+        [HttpPost("week-rolled")]
+        [ProducesResponseType(typeof(WeekRolledJobResult), StatusCodes.Status200OK)]
+        public async Task<ActionResult<WeekRolledJobResult>> RunWeekRolled(
+            [FromQuery] DateOnly? sourceWeekStart,
+            CancellationToken cancellationToken)
+        {
+            var weekStart = sourceWeekStart
+                ?? WorkOrderOperationalWeek.GetPreviousOperationalWeekStart(DateTime.UtcNow);
+
+            if (weekStart.DayOfWeek != DayOfWeek.Monday)
+                return BadRequest("sourceWeekStart must be a Monday (operational week start).");
+
+            var result = await _weekRolledService.ProcessWeekRolledAsync(weekStart, cancellationToken);
+            return Ok(result);
+        }
+
+        /// <summary>
+        /// Refresh optional OperationalFlags.PastDue cache (board isPastDue remains on-read).
+        /// </summary>
+        [HttpPost("past-due-cache")]
+        [ProducesResponseType(typeof(PastDueCacheJobResult), StatusCodes.Status200OK)]
+        public async Task<ActionResult<PastDueCacheJobResult>> RunPastDueCache(CancellationToken cancellationToken)
+        {
+            var result = await _pastDueCacheService.RefreshAsync(cancellationToken);
+            return Ok(result);
+        }
+    }
+}
diff --git a/Api.SeaHavenIndustries/Controllers/WorkOrderOpsController.cs b/Api.SeaHavenIndustries/Controllers/WorkOrderOpsController.cs
new file mode 100644
index 0000000..dfbff62
--- /dev/null
+++ b/Api.SeaHavenIndustries/Controllers/WorkOrderOpsController.cs
@@ -0,0 +1,29 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using SeaHaven.Services.DTOs;
+using SeaHaven.Services.Interfaces;
+
+namespace Api.SeaHavenIndustries.Controllers
+{
+    /// <summary>Ops health and coexistence metrics (Fase 7).</summary>
+    [Authorize(Roles = "Admin")]
+    [ApiController]
+    [Route("api/workorders/ops")]
+    public class WorkOrderOpsController : ControllerBase
+    {
+        private readonly IWorkOrderOpsHealthService _healthService;
+
+        public WorkOrderOpsController(IWorkOrderOpsHealthService healthService)
+        {
+            _healthService = healthService;
+        }
+
+        [HttpGet("health")]
+        [ProducesResponseType(typeof(WorkOrderOpsHealthDto), StatusCodes.Status200OK)]
+        public async Task<ActionResult<WorkOrderOpsHealthDto>> GetHealth(CancellationToken cancellationToken)
+        {
+            var health = await _healthService.GetHealthAsync(cancellationToken);
+            return Ok(health);
+        }
+    }
+}
diff --git a/Api.SeaHavenIndustries/Filters/ConcurrencyExceptionFilter.cs b/Api.SeaHavenIndustries/Filters/ConcurrencyExceptionFilter.cs
new file mode 100644
index 0000000..6b84ee6
--- /dev/null
+++ b/Api.SeaHavenIndustries/Filters/ConcurrencyExceptionFilter.cs
@@ -0,0 +1,22 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Filters;
+using Microsoft.EntityFrameworkCore;
+
+namespace Api.SeaHavenIndustries.Filters
+{
+    public class ConcurrencyExceptionFilter : IExceptionFilter
+    {
+        public void OnException(ExceptionContext context)
+        {
+            if (context.Exception is not DbUpdateConcurrencyException) return;
+
+            context.Result = new ConflictObjectResult(new
+            {
+                status = "Conflict",
+                message = "The record was modified by another user. Refresh and retry.",
+                code = 409
+            });
+            context.ExceptionHandled = true;
+        }
+    }
+}
diff --git a/Api.SeaHavenIndustries/Filters/IngestApiKeyFilter.cs b/Api.SeaHavenIndustries/Filters/IngestApiKeyFilter.cs
new file mode 100644
index 0000000..b98bfcc
--- /dev/null
+++ b/Api.SeaHavenIndustries/Filters/IngestApiKeyFilter.cs
@@ -0,0 +1,67 @@
+using System.Security.Cryptography;
+using System.Text;
+using Api.SeaHavenIndustries.Options;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Filters;
+using Microsoft.Extensions.Options;
+
+namespace Api.SeaHavenIndustries.Filters
+{
+    /// <summary>Validates X-Ingest-Key for POST /api/workorders/ingest.</summary>
+    public class IngestApiKeyFilter : IAsyncActionFilter
+    {
+        private readonly WorkOrderIngestOptions _options;
+
+        public IngestApiKeyFilter(IOptions<WorkOrderIngestOptions> options)
+        {
+            _options = options.Value;
+        }
+
+        public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
+        {
+            if (!_options.Enabled)
+            {
+                context.Result = new ObjectResult(new { message = "Work order ingest is disabled." })
+                {
+                    StatusCode = StatusCodes.Status503ServiceUnavailable
+                };
+                return;
+            }
+
+            if (string.IsNullOrWhiteSpace(_options.ApiKey)
+                || _options.ApiKey.Contains("${", StringComparison.Ordinal))
+            {
+                context.Result = new ObjectResult(new { message = "Ingest API key is not configured." })
+                {
+                    StatusCode = StatusCodes.Status503ServiceUnavailable
+                };
+                return;
+            }
+
+            if (!context.HttpContext.Request.Headers.TryGetValue("X-Ingest-Key", out var provided)
+                || !FixedTimeEquals(provided.ToString(), _options.ApiKey))
+            {
+                context.Result = new UnauthorizedObjectResult(new { message = "Invalid or missing X-Ingest-Key." });
+                return;
+            }
+
+            await next();
+        }
+
+        private static bool FixedTimeEquals(string provided, string expected)
+        {
+            var providedBytes = Encoding.UTF8.GetBytes(provided);
+            var expectedBytes = Encoding.UTF8.GetBytes(expected);
+            return providedBytes.Length == expectedBytes.Length
+                && CryptographicOperations.FixedTimeEquals(providedBytes, expectedBytes);
+        }
+    }
+
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
+    public sealed class IngestApiKeyAttribute : ServiceFilterAttribute
+    {
+        public IngestApiKeyAttribute() : base(typeof(IngestApiKeyFilter))
+        {
+        }
+    }
+}
diff --git a/Api.SeaHavenIndustries/HostedServices/PastDueCacheHostedService.cs b/Api.SeaHavenIndustries/HostedServices/PastDueCacheHostedService.cs
new file mode 100644
index 0000000..6daf1f7
--- /dev/null
+++ b/Api.SeaHavenIndustries/HostedServices/PastDueCacheHostedService.cs
@@ -0,0 +1,76 @@
+using Microsoft.Extensions.Options;
+using SeaHaven.Services.Implementation;
+using SeaHaven.Services.Interfaces;
+using Api.SeaHavenIndustries.Options;
+
+namespace Api.SeaHavenIndustries.HostedServices
+{
+    public class PastDueCacheHostedService : BackgroundService
+    {
+        private readonly IServiceScopeFactory _scopeFactory;
+        private readonly ILogger<PastDueCacheHostedService> _logger;
+        private readonly PastDueCacheJobOptions _options;
+        private readonly WorkOrderJobRunState _runState;
+        private DateOnly? _lastRunDate;
+
+        public PastDueCacheHostedService(
+            IServiceScopeFactory scopeFactory,
+            IOptions<WorkOrderJobsOptions> options,
+            WorkOrderJobRunState runState,
+            ILogger<PastDueCacheHostedService> logger)
+        {
+            _scopeFactory = scopeFactory;
+            _logger = logger;
+            _options = options.Value.PastDueCache;
+            _runState = runState;
+        }
+
+        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+        {
+            while (!stoppingToken.IsCancellationRequested)
+            {
+                if (_options.Enabled && ShouldRunNow())
+                {
+                    var today = DateOnly.FromDateTime(DateTime.UtcNow);
+                    if (_lastRunDate != today)
+                    {
+                        if (await RunJobAsync(stoppingToken))
+                            _lastRunDate = today;
+                    }
+                }
+
+                await Task.Delay(TimeSpan.FromMinutes(1), stoppingToken);
+            }
+        }
+
+        private async Task<bool> RunJobAsync(CancellationToken stoppingToken)
+        {
+            try
+            {
+                using var scope = _scopeFactory.CreateScope();
+                var service = scope.ServiceProvider.GetRequiredService<IPastDueCacheService>();
+                await service.RefreshAsync(stoppingToken);
+
+                _runState.LastPastDueCacheRunUtc = DateTime.UtcNow;
+                _runState.LastPastDueCacheError = null;
+                return true;
+            }
+            catch (Exception ex) when (ex is not OperationCanceledException)
+            {
+                _runState.LastPastDueCacheError = ex.Message;
+                _logger.LogError(ex, "PastDue cache hosted job failed.");
+                return false;
+            }
+        }
+
+        private bool ShouldRunNow()
+        {
+            var now = DateTime.UtcNow;
+
+            if (!TimeOnly.TryParse(_options.RunAtUtc, out var runAt))
+                runAt = new TimeOnly(0, 10);
+
+            return TimeOnly.FromDateTime(now) >= runAt;
+        }
+    }
+}
diff --git a/Api.SeaHavenIndustries/HostedServices/WorkOrderWeekRolledHostedService.cs b/Api.SeaHavenIndustries/HostedServices/WorkOrderWeekRolledHostedService.cs
new file mode 100644
index 0000000..dc5a309
--- /dev/null
+++ b/Api.SeaHavenIndustries/HostedServices/WorkOrderWeekRolledHostedService.cs
@@ -0,0 +1,84 @@
+using Microsoft.Extensions.Options;
+using SeaHaven.Services.Helpers;
+using SeaHaven.Services.Implementation;
+using SeaHaven.Services.Interfaces;
+using Api.SeaHavenIndustries.Options;
+
+namespace Api.SeaHavenIndustries.HostedServices
+{
+    public class WorkOrderWeekRolledHostedService : BackgroundService
+    {
+        private readonly IServiceScopeFactory _scopeFactory;
+        private readonly ILogger<WorkOrderWeekRolledHostedService> _logger;
+        private readonly WeekRolledJobOptions _options;
+        private readonly WorkOrderJobRunState _runState;
+        private DateOnly? _lastRunDate;
+
+        public WorkOrderWeekRolledHostedService(
+            IServiceScopeFactory scopeFactory,
+            IOptions<WorkOrderJobsOptions> options,
+            WorkOrderJobRunState runState,
+            ILogger<WorkOrderWeekRolledHostedService> logger)
+        {
+            _scopeFactory = scopeFactory;
+            _logger = logger;
+            _options = options.Value.WeekRolled;
+            _runState = runState;
+        }
+
+        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+        {
+            while (!stoppingToken.IsCancellationRequested)
+            {
+                if (_options.Enabled && ShouldRunNow())
+                {
+                    var today = DateOnly.FromDateTime(DateTime.UtcNow);
+                    if (_lastRunDate != today)
+                    {
+                        if (await RunJobAsync(stoppingToken))
+                            _lastRunDate = today;
+                    }
+                }
+
+                await Task.Delay(TimeSpan.FromMinutes(1), stoppingToken);
+            }
+        }
+
+        private async Task<bool> RunJobAsync(CancellationToken stoppingToken)
+        {
+            try
+            {
+                var sourceWeekStart = WorkOrderOperationalWeek.GetPreviousOperationalWeekStart(DateTime.UtcNow);
+
+                using var scope = _scopeFactory.CreateScope();
+                var service = scope.ServiceProvider.GetRequiredService<IWorkOrderWeekRolledService>();
+                await service.ProcessWeekRolledAsync(sourceWeekStart, stoppingToken);
+
+                _runState.LastWeekRolledRunUtc = DateTime.UtcNow;
+                _runState.LastWeekRolledError = null;
+                return true;
+            }
+            catch (Exception ex) when (ex is not OperationCanceledException)
+            {
+                _runState.LastWeekRolledError = ex.Message;
+                _logger.LogError(ex, "WeekRolled hosted job failed.");
+                return false;
+            }
+        }
+
+        private bool ShouldRunNow()
+        {
+            var now = DateTime.UtcNow;
+            if (!Enum.TryParse<DayOfWeek>(_options.DayOfWeek, ignoreCase: true, out var targetDay))
+                targetDay = DayOfWeek.Monday;
+
+            if (now.DayOfWeek != targetDay)
+                return false;
+
+            if (!TimeOnly.TryParse(_options.RunAtUtc, out var runAt))
+                runAt = new TimeOnly(0, 5);
+
+            return TimeOnly.FromDateTime(now) >= runAt;
+        }
+    }
+}
diff --git a/Api.SeaHavenIndustries/Middleware/LegacyDeprecationMiddleware.cs b/Api.SeaHavenIndustries/Middleware/LegacyDeprecationMiddleware.cs
new file mode 100644
index 0000000..0e2ccb6
--- /dev/null
+++ b/Api.SeaHavenIndustries/Middleware/LegacyDeprecationMiddleware.cs
@@ -0,0 +1,57 @@
+using Api.SeaHavenIndustries.Options;
+using Microsoft.Extensions.Options;
+
+namespace Api.SeaHavenIndustries.Middleware
+{
+    /// <summary>Adds Sunset/Deprecation headers to legacy WorkOrder REST routes.</summary>
+    public class LegacyDeprecationMiddleware
+    {
+        private static readonly HashSet<string> LegacyPathSegments = new(StringComparer.OrdinalIgnoreCase)
+        {
+            "GetWorkOrderList",
+            "AddWorkorder",
+            "EditWorkorder",
+            "ChangeStatus",
+            "ChangeAssignment",
+            "DeleteWorkorder",
+            "GetWorkorderById"
+        };
+
+        private readonly RequestDelegate _next;
+        private readonly LegacyEndpointOptions _options;
+
+        public LegacyDeprecationMiddleware(RequestDelegate next, IOptions<LegacyEndpointOptions> options)
+        {
+            _next = next;
+            _options = options.Value;
+        }
+
+        public async Task InvokeAsync(HttpContext context)
+        {
+            if (_options.DeprecationEnabled)
+            {
+                var path = context.Request.Path.Value ?? "";
+                var isLegacyWo = (path.Contains("/WorkOrder", StringComparison.OrdinalIgnoreCase)
+                        || path.Contains("/workorders", StringComparison.OrdinalIgnoreCase))
+                    && LegacyPathSegments.Any(seg => path.Contains(seg, StringComparison.OrdinalIgnoreCase));
+
+                if (isLegacyWo)
+                {
+                    context.Response.OnStarting(() =>
+                    {
+                        context.Response.Headers["Deprecation"] = "true";
+                        if (!string.IsNullOrWhiteSpace(_options.SunsetDate)
+                            && DateTimeOffset.TryParse(_options.SunsetDate, out var sunset))
+                        {
+                            context.Response.Headers["Sunset"] = sunset.UtcDateTime.ToString("r");
+                        }
+                        context.Response.Headers["Link"] = "</api/workorders/board>; rel=\"successor-version\"";
+                        return Task.CompletedTask;
+                    });
+                }
+            }
+
+            await _next(context);
+        }
+    }
+}
diff --git a/Api.SeaHavenIndustries/Options/LegacyEndpointOptions.cs b/Api.SeaHavenIndustries/Options/LegacyEndpointOptions.cs
new file mode 100644
index 0000000..ffd01ef
--- /dev/null
+++ b/Api.SeaHavenIndustries/Options/LegacyEndpointOptions.cs
@@ -0,0 +1,12 @@
+namespace Api.SeaHavenIndustries.Options
+{
+    public class LegacyEndpointOptions
+    {
+        public const string SectionName = "LegacyEndpoints";
+
+        public bool DeprecationEnabled { get; set; }
+
+        /// <summary>ISO date returned in Sunset header (e.g. 2026-12-31).</summary>
+        public string? SunsetDate { get; set; }
+    }
+}
diff --git a/Api.SeaHavenIndustries/Options/SyncOptions.cs b/Api.SeaHavenIndustries/Options/SyncOptions.cs
new file mode 100644
index 0000000..230e16c
--- /dev/null
+++ b/Api.SeaHavenIndustries/Options/SyncOptions.cs
@@ -0,0 +1,10 @@
+namespace Api.SeaHavenIndustries.Options
+{
+    public class SyncOptions
+    {
+        public const string SectionName = "Sync";
+
+        /// <summary>When false, SyncController endpoints return 503 (post-Lambda cutover). Default false to avoid dual-run with ingest.</summary>
+        public bool Enabled { get; set; }
+    }
+}
diff --git a/Api.SeaHavenIndustries/Options/WorkOrderIngestOptions.cs b/Api.SeaHavenIndustries/Options/WorkOrderIngestOptions.cs
new file mode 100644
index 0000000..96bed87
--- /dev/null
+++ b/Api.SeaHavenIndustries/Options/WorkOrderIngestOptions.cs
@@ -0,0 +1,13 @@
+namespace Api.SeaHavenIndustries.Options
+{
+    public class WorkOrderIngestOptions
+    {
+        public const string SectionName = "WorkOrderIngest";
+
+        /// <summary>When false, ingest endpoints return 503. Default false until a real ApiKey is provisioned.</summary>
+        public bool Enabled { get; set; }
+
+        /// <summary>Shared secret for X-Ingest-Key header (Lambda / service accounts).</summary>
+        public string? ApiKey { get; set; }
+    }
+}
diff --git a/Api.SeaHavenIndustries/Options/WorkOrderJobsOptions.cs b/Api.SeaHavenIndustries/Options/WorkOrderJobsOptions.cs
new file mode 100644
index 0000000..791638c
--- /dev/null
+++ b/Api.SeaHavenIndustries/Options/WorkOrderJobsOptions.cs
@@ -0,0 +1,23 @@
+namespace Api.SeaHavenIndustries.Options
+{
+    public class WorkOrderJobsOptions
+    {
+        public const string SectionName = "WorkOrderJobs";
+
+        public WeekRolledJobOptions WeekRolled { get; set; } = new();
+        public PastDueCacheJobOptions PastDueCache { get; set; } = new();
+    }
+
+    public class WeekRolledJobOptions
+    {
+        public bool Enabled { get; set; } = true;
+        public string RunAtUtc { get; set; } = "00:05";
+        public string DayOfWeek { get; set; } = "Monday";
+    }
+
+    public class PastDueCacheJobOptions
+    {
+        public bool Enabled { get; set; }
+        public string RunAtUtc { get; set; } = "00:10";
+    }
+}
diff --git a/Api.SeaHavenIndustries/Program.cs b/Api.SeaHavenIndustries/Program.cs
index a826847..c85271b 100644
--- a/Api.SeaHavenIndustries/Program.cs
+++ b/Api.SeaHavenIndustries/Program.cs
@@ -1,4 +1,7 @@
 using Api.SeaHavenIndustries.Helper;
+using Api.SeaHavenIndustries.HostedServices;
+using Api.SeaHavenIndustries.Middleware;
+using Api.SeaHavenIndustries.Options;
 using Data.SeaHavenIndustries;
 using Microsoft.AspNetCore.Authentication.JwtBearer;
 using Microsoft.AspNetCore.Identity;
@@ -9,6 +12,7 @@ using Microsoft.OpenApi.Models;
 using System.Text;
 using SeaHaven.DataServices.DependencyInjection;
 using SeaHaven.Services.DependencyInjection;
+using SeaHaven.Services.Implementation;
 
 var builder = WebApplication.CreateBuilder(args);
 ConfigurationManager configuration = builder.Configuration;
@@ -22,7 +26,10 @@ builder.Services.AddIdentity<ApplicationUser, IdentityRole>(options =>
     .AddEntityFrameworkStores<ApplicationDbContext>()
     .AddDefaultTokenProviders();
 
-builder.Services.AddControllers().AddJsonOptions(options =>
+builder.Services.AddControllers(options =>
+{
+    options.Filters.Add<Api.SeaHavenIndustries.Filters.ConcurrencyExceptionFilter>();
+}).AddJsonOptions(options =>
 {
     options.JsonSerializerOptions.MaxDepth = 264; // or any other desired value
 });
@@ -48,6 +55,38 @@ builder.Services.AddSingleton<Api.SeaHavenIndustries.Helper.ZipCodeDistance>(sp
 builder.Services.AddDataServices();
 builder.Services.AddBusinessServices();
 
+builder.Services.Configure<WorkOrderJobsOptions>(
+    builder.Configuration.GetSection(WorkOrderJobsOptions.SectionName));
+builder.Services.AddOptions<WorkOrderIngestOptions>()
+    .Bind(builder.Configuration.GetSection(WorkOrderIngestOptions.SectionName))
+    .Validate(
+        o => !o.Enabled
+            || (!string.IsNullOrWhiteSpace(o.ApiKey)
+                && !o.ApiKey.Contains("${", StringComparison.Ordinal)
+                && o.ApiKey.Length >= 32),
+        "WorkOrderIngest:ApiKey must be a real secret (env/user-secrets, length >= 32) when ingest is enabled.")
+    .ValidateOnStart();
+builder.Services.Configure<SyncOptions>(
+    builder.Configuration.GetSection(SyncOptions.SectionName));
+builder.Services.Configure<LegacyEndpointOptions>(
+    builder.Configuration.GetSection(LegacyEndpointOptions.SectionName));
+builder.Services.AddSingleton<WorkOrderJobRunStateAccessor>();
+builder.Services.AddSingleton(sp => sp.GetRequiredService<WorkOrderJobRunStateAccessor>().State);
+builder.Services.AddScoped<Api.SeaHavenIndustries.Filters.IngestApiKeyFilter>();
+builder.Services.AddHostedService<WorkOrderWeekRolledHostedService>();
+builder.Services.AddHostedService<PastDueCacheHostedService>();
+builder.Services.AddOptions<SeaHaven.Services.Implementation.WorkOrderOpsHealthOptions>()
+    .Configure<Microsoft.Extensions.Options.IOptions<SyncOptions>,
+        Microsoft.Extensions.Options.IOptions<WorkOrderIngestOptions>,
+        Microsoft.Extensions.Options.IOptions<LegacyEndpointOptions>>(
+        (health, sync, ingest, legacy) =>
+        {
+            health.SyncEnabled = sync.Value.Enabled;
+            health.IngestEnabled = ingest.Value.Enabled;
+            health.LegacyDeprecationEnabled = legacy.Value.DeprecationEnabled;
+            health.LegacySunsetDate = legacy.Value.SunsetDate;
+        });
+
 builder.Services.AddAuthentication(options =>
 {
     options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
@@ -113,6 +152,7 @@ if (!app.Environment.IsDevelopment())
     app.UseHttpsRedirection();
 app.UseStaticFiles();
 app.UseCors();
+app.UseMiddleware<LegacyDeprecationMiddleware>();
 app.UseAuthentication();
 app.UseAuthorization();
 
diff --git a/Api.SeaHavenIndustries/appsettings.json b/Api.SeaHavenIndustries/appsettings.json
index 2d5dc80..85941e0 100644
--- a/Api.SeaHavenIndustries/appsettings.json
+++ b/Api.SeaHavenIndustries/appsettings.json
@@ -1,4 +1,4 @@
-{
+{
   "ConnectionStrings": {
     //"DefaultConnection": "Server=DESKTOP-64LC14O\SQLEXPRESS;Database=SeahavenIndustries;TrustServerCertificate=True;Trusted_Connection=True;MultipleActiveResultSets=true",
 
@@ -23,5 +23,22 @@
     "ValidIssuer": "http://localhost:7195",
     // Provide the real value via environment variable JWT__Secret or user-secrets.
     "Secret": "${JWT_SECRET}"
-  }
-}
\ No newline at end of file
+  },
+  "WorkOrderJobs": {
+    "WeekRolled": { "Enabled": true, "RunAtUtc": "00:05", "DayOfWeek": "Monday" },
+    "PastDueCache": { "Enabled": false, "RunAtUtc": "00:10" }
+  },
+  "WorkOrderIngest": {
+    "Enabled": false,
+    "ApiKey": "${WORKORDER_INGEST_API_KEY}"
+  },
+  "Sync": {
+    "Enabled": true
+  },
+  "LegacyEndpoints": {
+    "DeprecationEnabled": false,
+    "SunsetDate": "2026-12-31"
+  },
+  "FrontendBaseUrl": "https://shoc.seahaven.com"
+}
+
diff --git a/Data.SeaHavenIndustries/Auth/ApplicationDbContext.cs b/Data.SeaHavenIndustries/Auth/ApplicationDbContext.cs
index ea60e8e..9216004 100644
--- a/Data.SeaHavenIndustries/Auth/ApplicationDbContext.cs
+++ b/Data.SeaHavenIndustries/Auth/ApplicationDbContext.cs
@@ -33,6 +33,77 @@ namespace Data.SeaHavenIndustries
                 .HasIndex(u => new { u.DispatchId, u.Status })
                 .IsUnique()
                 .HasFilter("[Status] = 'Pending'");
+
+            builder.Entity<WorkOrderFieldLock>()
+                .HasIndex(l => new { l.WorkOrderId, l.FieldName })
+                .IsUnique();
+
+            builder.Entity<WorkOrderWeekRolledLedger>()
+                .HasIndex(l => new { l.WorkOrderId, l.SourceWeekStart })
+                .IsUnique();
+
+            builder.Entity<CompletionDocTemplate>()
+                .HasIndex(t => new { t.ServiceKey, t.IsActive });
+
+            builder.Entity<WorkOrder>()
+                .Property(w => w.RowVersion)
+                .IsRowVersion();
+
+            builder.Entity<WorkOrder>()
+                .Property(w => w.SiteCode)
+                .HasMaxLength(450);
+
+            builder.Entity<WorkOrder>()
+                .HasIndex(w => w.SiteCode)
+                .HasFilter("[istemplate] = 0");
+
+            builder.Entity<WorkOrder>()
+                .Property(w => w.InternalWONumber)
+                .HasMaxLength(450);
+
+            builder.Entity<WorkOrder>()
+                .HasIndex(w => w.InternalWONumber)
+                .HasFilter("[istemplate] = 0");
+
+            builder.Entity<WorkOrder>()
+                .HasIndex(w => new { w.LifecycleStatus, w.ScheduledDate })
+                .HasFilter("[istemplate] = 0");
+
+            // Phase 1 board indexes (must stay in model to match snapshot / existing DBs).
+            builder.Entity<WorkOrder>()
+                .HasIndex(w => w.AssignTo);
+
+            builder.Entity<WorkOrder>()
+                .HasIndex(w => w.ScheduledDate);
+
+            builder.Entity<WorkOrder>()
+                .HasIndex(w => new { w.AssignTo, w.ScheduledDate });
+
+            builder.Entity<WorkOrder>()
+                .HasIndex(w => w.WorkOrderType);
+
+            builder.Entity<WorkOrder>()
+                .Property(w => w.Service)
+                .HasMaxLength(128);
+
+            builder.Entity<WorkOrder>()
+                .Property(w => w.ExternalWorkOrderId)
+                .HasMaxLength(450);
+
+            builder.Entity<WorkOrder>()
+                .HasIndex(w => w.ExternalWorkOrderId)
+                .IsUnique()
+                .HasFilter("[ExternalWorkOrderId] IS NOT NULL AND [ExternalWorkOrderId] <> ''");
+
+            builder.Entity<Dispatch>()
+                .Property(d => d.RowVersion)
+                .IsRowVersion();
+
+            builder.Entity<WorkOrder>()
+                .HasOne(w => w.PrimaryDispatch)
+                .WithMany()
+                .HasForeignKey(w => w.PrimaryDispatchId)
+                .OnDelete(DeleteBehavior.Restrict);
         }
         public DbSet<Category> Categories { get; set; }
         public DbSet<Locations> Locations { get; set; }
@@ -46,7 +117,10 @@ namespace Data.SeaHavenIndustries
         public DbSet<WorkOrderContacts> WorkOrderContacts { get; set; }
         public DbSet<WorkOrderCategories> workOrderCategories { get; set; }
         public DbSet<WorkOrderAttachments> workOrderAttachments { get; set; }
+        public DbSet<CompletionDocTemplate> CompletionDocTemplates { get; set; }
         public DbSet<WorkOrderAuditLog> WorkOrderAuditLogs { get; set; }
+        public DbSet<WorkOrderFieldLock> WorkOrderFieldLocks { get; set; }
+        public DbSet<WorkOrderWeekRolledLedger> WorkOrderWeekRolledLedgers { get; set; }
         public DbSet<DropdownOption> DropdownOptions { get; set; }
         public DbSet<Vendor> Vendors { get; set; }
         public DbSet<VendorAccessToken> VendorAccessTokens { get; set; }
@@ -75,6 +149,51 @@ namespace Data.SeaHavenIndustries
         public DbSet<Department> Departments { get; set; }
         public DbSet<JobTitle> JobTitles { get; set; }
         public DbSet<Region> Regions { get; set; }
+
+        public override int SaveChanges()
+        {
+            BumpRowVersionsForInMemoryProvider();
+            return base.SaveChanges();
+        }
+
+        public override Task<int> SaveChangesAsync(CancellationToken cancellationToken = default)
+        {
+            BumpRowVersionsForInMemoryProvider();
+            return base.SaveChangesAsync(cancellationToken);
+        }
+
+        private void BumpRowVersionsForInMemoryProvider()
+        {
+            if (!Database.ProviderName?.Contains("InMemory", StringComparison.OrdinalIgnoreCase) ?? true)
+                return;
+
+            foreach (var entry in ChangeTracker.Entries<WorkOrder>())
+            {
+                if (entry.State == EntityState.Modified)
+                    entry.Entity.RowVersion = IncrementRowVersion(entry.Entity.RowVersion);
+            }
+
+            foreach (var entry in ChangeTracker.Entries<Dispatch>())
+            {
+                if (entry.State == EntityState.Modified)
+                    entry.Entity.RowVersion = IncrementRowVersion(entry.Entity.RowVersion);
+            }
+        }
+
+        private static byte[] IncrementRowVersion(byte[]? current)
+        {
+            var bytes = current != null && current.Length > 0
+                ? (byte[])current.Clone()
+                : new byte[] { 0, 0, 0, 0, 0, 0, 0, 1 };
+
+            for (var i = 0; i < bytes.Length; i++)
+            {
+                if (++bytes[i] != 0)
+                    break;
+            }
+
+            return bytes;
+        }
    
     }
     public class ApplicationUser : IdentityUser
@@ -88,6 +207,8 @@ namespace Data.SeaHavenIndustries
         public DateTime? DeletedDate { get; set; }
         public bool? IsDeleted { get; set; }
         public string? UserImage { get; set; }
+        public string? Initials { get; set; }
+        public string? Color { get; set; }
         public int? Type { get; set; } // 1 for users 0 for admin
        public ICollection<Template>? Templates { get; set; }
        public ICollection<WorkOrder>? WorkOrders { get; set; }
diff --git a/Data.SeaHavenIndustries/Enums/WorkOrderEnums.cs b/Data.SeaHavenIndustries/Enums/WorkOrderEnums.cs
index 9c2e454..b8db7fc 100644
--- a/Data.SeaHavenIndustries/Enums/WorkOrderEnums.cs
+++ b/Data.SeaHavenIndustries/Enums/WorkOrderEnums.cs
@@ -1,92 +1,171 @@
-namespace Data.SeaHavenIndustries.Enums
-{
-    public enum WorkOrderStatus
-    {
-        Open = 1,
-        InProgress = 2,
-        Completed = 3,
-        Cancelled = 4,
-        OnHold = 5
-    }
-
-    public enum WorkOrderPriority
-    {
-        Low = 1,
-        Medium = 2,
-        High = 3,
-        Critical = 4
-    }
-
-    public enum AuditAction
-    {
-        Create = 1,
-        Edit = 2,
-        Delete = 3,
-        StatusChange = 4,
-        AssignmentChange = 5,
-        Dispatch = 6,
-        DispatchUpdate = 7,
-        DispatchVerify = 8
-    }
-
-    public enum ContactType
-    {
-        Primary = 1,
-        Secondary = 2,
-        Billing = 3,
-        Technical = 4
-    }
-
-    public enum AssetStatus
-    {
-        Active = 1,
-        Inactive = 2,
-        UnderMaintenance = 3,
-        Retired = 4
-    }
-
-    public enum DispatchStatus
-    {
-        Pending = 1,
-        Assigned = 2,
-        InProgress = 3,
-        Completed = 4,
-        Cancelled = 5
-    }
-
-    public enum FollowUpStatus
-    {
-        Open = 1,
-        InProgress = 2,
-        Resolved = 3,
-        Closed = 4
-    }
-
-    public enum PMScheduleFrequency
-    {
-        Daily = 1,
-        Weekly = 2,
-        Monthly = 3,
-        Quarterly = 4,
-        SemiAnnual = 5,
-        Annual = 6
-    }
-
-    public enum CommentType
-    {
-        General = 1,
-        Internal = 2,
-        Customer = 3,
-        Vendor = 4,
-        System = 5
-    }
-
-    public enum RecordType
-    {
-        WorkOrder = 1,
-        Dispatch = 2,
-        Quote = 3,
-        Contact = 4,
-        Asset = 5
-    }
-}
+namespace Data.SeaHavenIndustries.Enums

+{

+    /// <summary>Legacy enum — prefer LifecycleStatus for board operations.</summary>

+    public enum WorkOrderStatus

+    {

+        Open = 1,

+        InProgress = 2,

+        Completed = 3,

+        Cancelled = 4,

+        OnHold = 5

+    }

+

+    /// <summary>10 operational lifecycle values aligned with SHOC board (FE labels).</summary>

+    public enum LifecycleStatus

+    {

+        Incomplete = 1,

+        Pending = 2,

+        Scheduled = 3,

+        EnRoute = 4,

+        OnSite = 5,

+        InProgress = 6,

+        Completed = 7,

+        Rescheduled = 8,

+        Canceled = 9,

+        PendingQuote = 10

+    }

+

+    /// <summary>Board work-order types. Legacy values retained for backward compatibility.</summary>

+    public enum WorkOrderType

+    {

+        PO = 1,

+        PM = 2,

+        Emergency = 3,

+        Project = 4,

+        Inspection = 5,

+        Reactive = 6,

+        AddOn = 7,

+        Other = 99

+    }

+

+    public enum DocStatus

+    {

+        Yes = 1,

+        No = 2,

+        NotNeeded = 3

+    }

+

+    [Flags]

+    public enum OperationalFlags

+    {

+        None = 0,

+        PastDue = 1

+    }

+

+    public enum AuditEventType

+    {

+        Manual = 1,

+        System = 2,

+        Sync = 3,

+        Vendor = 4

+    }

+

+    public enum AuditActorType

+    {

+        Dispatcher = 1,

+        Vendor = 2,

+        System = 3,

+        Sync = 4

+    }

+

+    public enum AuditActionType

+    {

+        FieldChanged = 1,

+        StatusChanged = 2,

+        AssignmentChanged = 3,

+        WeekRolled = 4,

+        SyncRejected = 5,

+        Create = 6,

+        Delete = 7

+    }

+

+    public enum WorkOrderPriority

+    {

+        Low = 1,

+        Medium = 2,

+        High = 3,

+        Critical = 4

+    }

+

+    public enum AuditAction

+    {

+        Create = 1,

+        Edit = 2,

+        Delete = 3,

+        StatusChange = 4,

+        AssignmentChange = 5,

+        Dispatch = 6,

+        DispatchUpdate = 7,

+        DispatchVerify = 8

+    }

+

+    public enum ContactType

+    {

+        Primary = 1,

+        Secondary = 2,

+        Billing = 3,

+        Technical = 4

+    }

+

+    public enum AssetStatus

+    {

+        Active = 1,

+        Inactive = 2,

+        UnderMaintenance = 3,

+        Retired = 4

+    }

+

+    public enum DispatchStatus

+    {

+        Pending = 1,

+        Assigned = 2,

+        InProgress = 3,

+        Completed = 4,

+        Cancelled = 5

+    }

+

+    public enum FollowUpStatus

+    {

+        Open = 1,

+        InProgress = 2,

+        Resolved = 3,

+        Closed = 4

+    }

+

+    public enum PMScheduleFrequency

+    {

+        Daily = 1,

+        Weekly = 2,

+        Monthly = 3,

+        Quarterly = 4,

+        SemiAnnual = 5,

+        Annual = 6

+    }

+

+    public enum CommentType

+    {

+        General = 1,

+        Internal = 2,

+        Customer = 3,

+        Vendor = 4,

+        System = 5

+    }

+

+    public enum RecordType

+    {

+        WorkOrder = 1,

+        Dispatch = 2,

+        Quote = 3,

+        Contact = 4,

+        Asset = 5

+    }

+

+    public enum WorkOrderMediaCategory

+    {

+        Before = 1,

+        After = 2,

+        Extra = 3,

+        Completion = 4

+    }

+}

+
\ No newline at end of file
diff --git a/Data.SeaHavenIndustries/Migrations/20260619150000_AddWorkOrderTypeAndScheduledDateIndex.cs b/Data.SeaHavenIndustries/Migrations/20260619150000_AddWorkOrderTypeAndScheduledDateIndex.cs
new file mode 100644
index 0000000..e1e268e
--- /dev/null
+++ b/Data.SeaHavenIndustries/Migrations/20260619150000_AddWorkOrderTypeAndScheduledDateIndex.cs
@@ -0,0 +1,43 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Data.SeaHavenIndustries.Migrations
+{
+    public class AddWorkOrderTypeAndScheduledDateIndex : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.Sql("""
+                IF COL_LENGTH('workOrders', 'WorkOrderType') IS NULL
+                    ALTER TABLE workOrders ADD WorkOrderType varchar(50) NULL;
+                """);
+
+            migrationBuilder.Sql("""
+                IF NOT EXISTS (
+                    SELECT 1 FROM sys.indexes
+                    WHERE name = 'IX_workOrders_ScheduledDate'
+                      AND object_id = OBJECT_ID('workOrders'))
+                BEGIN
+                    CREATE INDEX IX_workOrders_ScheduledDate ON workOrders (ScheduledDate);
+                END
+                """);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.Sql("""
+                IF EXISTS (
+                    SELECT 1 FROM sys.indexes
+                    WHERE name = 'IX_workOrders_ScheduledDate'
+                      AND object_id = OBJECT_ID('workOrders'))
+                    DROP INDEX IX_workOrders_ScheduledDate ON workOrders;
+                """);
+
+            migrationBuilder.Sql("""
+                IF COL_LENGTH('workOrders', 'WorkOrderType') IS NOT NULL
+                    ALTER TABLE workOrders DROP COLUMN WorkOrderType;
+                """);
+        }
+    }
+}
diff --git a/Data.SeaHavenIndustries/Migrations/20260624163145_Phase0_DomainFoundation.Designer.cs b/Data.SeaHavenIndustries/Migrations/20260624163145_Phase0_DomainFoundation.Designer.cs
new file mode 100644
index 0000000..5092591
--- /dev/null
+++ b/Data.SeaHavenIndustries/Migrations/20260624163145_Phase0_DomainFoundation.Designer.cs
@@ -0,0 +1,2991 @@
+// <auto-generated />
+using System;
+using Data.SeaHavenIndustries;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace Data.SeaHavenIndustries.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20260624163145_Phase0_DomainFoundation")]
+    partial class Phase0_DomainFoundation
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.8")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Accounts", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("About")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CurrencyCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FacebookUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("Importance")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("IndustryId")
+                        .HasColumnType("int");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("LinkedInUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("OwnerEmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PrivacySetting")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ServiceInstructions")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Tags")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("TerritoryId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("TimeZone")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("TwitterUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Type")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Website")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Accounts");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Addresses", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("AccountId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Address1")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Address2")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("AddressType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("City")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Country")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("County")
+                        .HasColumnType("nvarchar(max)");
+
+                    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<string>("State")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Zip")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("ContactId");
+
+                    b.ToTable("Addresses");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.ApplicationUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Color")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Contact")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("FirstName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Initials")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Locations")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("bit");
+
+                    b.Property<int?>("Type")
+                        .HasColumnType("int");
+
+                    b.Property<string>("UniqueName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserImage")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex")
+                        .HasFilter("[NormalizedUserName] IS NOT NULL");
+
+                    b.ToTable("AspNetUsers", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Assets", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("AccountId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("AssetCode")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    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<int?>("LocationId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("LocationId");
+
+                    b.ToTable("Assets");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Category", 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<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Categories");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Comments", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("CommentType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Commenter")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Commenttext")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("DispatchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Documents")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ExternalCommentId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RecordType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<int?>("WorkerOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DispatchId");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("WorkerOrderId");
+
+                    b.ToTable("Comments");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.ContactDetails", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("About")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DateOfBirth")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("FacebookUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Gender")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("LinkedInUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PrivacySetting")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Tags")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Territory")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("TwitterUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContactId");
+
+                    b.ToTable("ContactDetails");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Contacts", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("AccountId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Address1")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Address2")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("City")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ContactType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FacebookUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FirstName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("LinkedInUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("LocationId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("MiddleName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("State")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("TwitterUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Zip")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("LocationId");
+
+                    b.ToTable("Contacts");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Department", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Departments");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Dispatch", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AcceptToken")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("AcknowledgedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("CompletedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DispatchNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DispatchedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<bool>("EmailSent")
+                        .HasColumnType("bit");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("NTEAmount")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("PONumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ReplyToAddress")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<byte[]>("RowVersion")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("rowversion");
+
+                    b.Property<DateTime?>("ScheduledDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("VerifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("VerifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("Dispatches");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.DispatchChecklistItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime?>("CompletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CompletedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("DispatchId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsCompleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("ItemText")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DispatchId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("DispatchChecklistItems");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.DispatchSignoff", 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<int>("DispatchId")
+                        .HasColumnType("int");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Signature")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SignatureMethod")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("SignedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("SignoffType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DispatchId");
+
+                    b.ToTable("DispatchSignoffs");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.DispatchUpliftRequest", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<decimal?>("CurrentNTE")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<DateTime?>("DecidedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DecidedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DecisionNote")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("DispatchId")
+                        .HasColumnType("int");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RequestedByVendorName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<decimal>("RequestedNTE")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("RequiredTier")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("nvarchar(20)");
+
+                    b.Property<string>("VendorReason")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DispatchId", "Status")
+                        .IsUnique()
+                        .HasFilter("[Status] = 'Pending'");
+
+                    b.ToTable("DispatchUpliftRequests");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.DispatchWorkOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("DispatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DispatchId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("DispatchWorkOrders");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.DropdownOption", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("ParentValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("DropdownOptions");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Employee", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("About")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool?>("CanChangeProviderNumber")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("ConfirmUserName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DateOfBirth")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("DepartmentId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EmployeeNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FacebookUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("Gender")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("HireDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<int?>("JobTitleId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("LastLogin")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("LastName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("LinkedInUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("MiddleName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("PermissionGroupId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("RegionId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SMSAddress")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("TimeZone")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("TwitterUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Website")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DepartmentId");
+
+                    b.HasIndex("JobTitleId");
+
+                    b.HasIndex("RegionId");
+
+                    b.ToTable("Employees");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.EmployeeAddress", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("City")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("CountryCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("CountyId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("StateCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Street")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("StreetLineTwo")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Zip")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmployeeId")
+                        .IsUnique();
+
+                    b.ToTable("EmployeeAddresses");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.EmployeeEmail", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Address")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<int?>("EmailTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<bool?>("IsPrimary")
+                        .HasColumnType("bit");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.ToTable("EmployeeEmails");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.EmployeePhone", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Extension")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool?>("IsPrimary")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Number")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("PhoneTypeId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.ToTable("EmployeePhones");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.FollowUps", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("AccountId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("LocationId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("ScheduleDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<TimeSpan>("ScheduleStartTime")
+                        .HasColumnType("time");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("FollowUps");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.ForgetPasswordCode", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ForgetPasswordCodes");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.JobTitle", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("JobTitles");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Locations", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Address1")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Address2")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("City")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Latitude")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Longitude")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("State")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Zip")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Locations");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.PMSchedules", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("AssetId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Frequency")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    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<int?>("LocationId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("StartDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.HasIndex("LocationId");
+
+                    b.ToTable("PMSchedules");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Quotes", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("BillingAddress")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("Date")
+                        .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<string>("PO")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ProjectName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("QuotId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ShippingAddress")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SiteId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SiteName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("TT")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("WorkorderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContactId");
+
+                    b.HasIndex("WorkorderId");
+
+                    b.ToTable("Quotes");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.QuotesLineItems", 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<string>("Descriptions")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("Lineitem")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int?>("LineitemNumber")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("QuoteId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("QuoteId");
+
+                    b.ToTable("QuotesLines");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Region", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Regions");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.TaskListTemplate", 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<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    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")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("TaskListTemplates");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.TaskListTemplateItem", 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<string>("ItemText")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TaskListTemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TaskListTemplateId");
+
+                    b.ToTable("TaskListTemplateItems");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Template", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AfterPhotoAttachment")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("AfterPhotoIssue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("AssignTo")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Attachments")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BeforPhotoAttachment")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BeforPhotoIssue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("CategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DueDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("LocationId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PO")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Priority")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SignOffAttachment")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SignOffName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SignOffSignature")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("TT")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("WorkerOrderNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("WorkerOrderTitle")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssignTo");
+
+                    b.HasIndex("CategoryId");
+
+                    b.HasIndex("ContactId");
+
+                    b.HasIndex("LocationId");
+
+                    b.ToTable("Templates");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Vendor", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Address")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("City")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("CompanyName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ContactName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    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>("Phone")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("State")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("TradeSpecialties")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Zip")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Vendors");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.VendorAccessToken", 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<DateTime>("ExpiresAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime>("IssuedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("LastUsedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("RevokedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Token")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("nvarchar(64)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Token")
+                        .IsUnique();
+
+                    b.HasIndex("VendorId");
+
+                    b.ToTable("VendorAccessTokens");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AfterPhotoAttachment")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("AfterPhotoIssue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateOnly?>("AssignDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("AssignTo")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Attachments")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("AvettaTask")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BeforPhotoAttachment")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BeforPhotoIssue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Building")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("CarriedOver")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("CompletedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Customer")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DateReported")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("DocStatus")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("DueDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("ExternalWorkOrderId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalWONumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("LegacyStatus")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("LifecycleStatus")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("LocationId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("OperationalFlags")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly?>("OriginalDate")
+                        .HasColumnType("date");
+
+                    b.Property<DateOnly?>("OriginalWeek")
+                        .HasColumnType("date");
+
+                    b.Property<string>("PO")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("PrimaryDispatchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Priority")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Problem")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("RescheduleCount")
+                        .HasColumnType("int");
+
+                    b.Property<byte[]>("RowVersion")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("rowversion");
+
+                    b.Property<bool?>("ScheduleWeekOnly")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("ScheduledDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ScheduledEnd")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ScheduledStart")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Severity")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Service")
+                        .HasMaxLength(128)
+                        .HasColumnType("nvarchar(128)");
+
+                    b.Property<string>("SignOffAttachment")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SignOffName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SignOffSignature")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SiteCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Source")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SourceEmailS3Key")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SubTrade")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("TT")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateOnly?>("TargetWeek")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Trade")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<decimal?>("VendorNTE")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int?>("WorkOrderType")
+                        .HasColumnType("int");
+
+                    b.Property<string>("WorkerOrderNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("WorkerOrderTitle")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool?>("istemplate")
+                        .HasColumnType("bit");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssignTo");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("PrimaryDispatchId");
+
+                    b.ToTable("workOrders");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderAttachments", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Attachments")
+                        .HasColumnType("nvarchar(max)");
+
+                    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?>("WorkorderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorkorderId");
+
+                    b.ToTable("workOrderAttachments");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderAuditLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Action")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ActorType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("CorrelationId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("DispatchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EventType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FieldName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("NewValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("OldValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("WorkOrderAuditLogs");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderCategories", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("CategoryId")
+                        .HasColumnType("int");
+
+                    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?>("WorkorderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CategoryId");
+
+                    b.HasIndex("WorkorderId");
+
+                    b.ToTable("workOrderCategories");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderContacts", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("ContactId")
+                        .HasColumnType("int");
+
+                    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<string>("Notes")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("WorkorderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContactId");
+
+                    b.HasIndex("WorkorderId");
+
+                    b.ToTable("WorkOrderContacts");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderFieldLock", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("FieldName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<DateTime>("LockedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LockedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorkOrderId", "FieldName")
+                        .IsUnique();
+
+                    b.ToTable("WorkOrderFieldLocks");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex")
+                        .HasFilter("[NormalizedName] IS NOT NULL");
+
+                    b.ToTable("AspNetRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("RoleId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Addresses", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Accounts", "Account")
+                        .WithMany("Addresses")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Contacts", "Contact")
+                        .WithMany()
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Account");
+
+                    b.Navigation("Contact");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Assets", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Accounts", "Account")
+                        .WithMany()
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Locations", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Account");
+
+                    b.Navigation("Location");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Comments", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Dispatch", "Dispatch")
+                        .WithMany("Comments")
+                        .HasForeignKey("DispatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.ApplicationUser", "ApplicationUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany("Comments")
+                        .HasForeignKey("WorkerOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("ApplicationUser");
+
+                    b.Navigation("Dispatch");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.ContactDetails", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Contacts", "Contact")
+                        .WithMany()
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Contact");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Contacts", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Accounts", "Account")
+                        .WithMany("Contacts")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Locations", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Account");
+
+                    b.Navigation("Location");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Dispatch", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Vendor", "Vendor")
+                        .WithMany("Dispatches")
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany("Dispatches")
+                        .HasForeignKey("WorkOrderId");
+
+                    b.Navigation("Vendor");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.DispatchChecklistItem", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Dispatch", "Dispatch")
+                        .WithMany("ChecklistItems")
+                        .HasForeignKey("DispatchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Dispatch");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.DispatchSignoff", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Dispatch", "Dispatch")
+                        .WithMany("Signoffs")
+                        .HasForeignKey("DispatchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Dispatch");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.DispatchUpliftRequest", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Dispatch", "Dispatch")
+                        .WithMany()
+                        .HasForeignKey("DispatchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Dispatch");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.DispatchWorkOrder", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Dispatch", "Dispatch")
+                        .WithMany("DispatchWorkOrders")
+                        .HasForeignKey("DispatchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Dispatch");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Employee", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Department", "Department")
+                        .WithMany("Employees")
+                        .HasForeignKey("DepartmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.JobTitle", "JobTitle")
+                        .WithMany("Employees")
+                        .HasForeignKey("JobTitleId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Region", "Region")
+                        .WithMany("Employees")
+                        .HasForeignKey("RegionId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Department");
+
+                    b.Navigation("JobTitle");
+
+                    b.Navigation("Region");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.EmployeeAddress", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Employee", "Employee")
+                        .WithOne("Address")
+                        .HasForeignKey("Data.SeaHavenIndustries.EmployeeAddress", "EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.EmployeeEmail", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Employee", "Employee")
+                        .WithMany("Emails")
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.EmployeePhone", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Employee", "Employee")
+                        .WithMany("Phones")
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.FollowUps", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Accounts", "Account")
+                        .WithMany()
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Locations", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Account");
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("Location");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.PMSchedules", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Assets", "Asset")
+                        .WithMany("PMSchedules")
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Locations", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Asset");
+
+                    b.Navigation("Location");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Quotes", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Contacts", "Contacts")
+                        .WithMany()
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany("Quotes")
+                        .HasForeignKey("WorkorderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Contacts");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.QuotesLineItems", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Quotes", "Quotes")
+                        .WithMany("LineItems")
+                        .HasForeignKey("QuoteId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Quotes");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.TaskListTemplateItem", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.TaskListTemplate", "Template")
+                        .WithMany("Items")
+                        .HasForeignKey("TaskListTemplateId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Template", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.ApplicationUser", "AssignToUser")
+                        .WithMany("Templates")
+                        .HasForeignKey("AssignTo")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Category", "Category")
+                        .WithMany("Templates")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Contacts", "POC")
+                        .WithMany()
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Locations", "Locations")
+                        .WithMany("Templates")
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("AssignToUser");
+
+                    b.Navigation("Category");
+
+                    b.Navigation("Locations");
+
+                    b.Navigation("POC");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.VendorAccessToken", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrder", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.ApplicationUser", "AssignToUser")
+                        .WithMany("WorkOrders")
+                        .HasForeignKey("AssignTo")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Locations", "Locations")
+                        .WithMany("workOrders")
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Dispatch", "PrimaryDispatch")
+                        .WithMany()
+                        .HasForeignKey("PrimaryDispatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("AssignToUser");
+
+                    b.Navigation("Locations");
+
+                    b.Navigation("PrimaryDispatch");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderAttachments", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany("workOrderAttachments")
+                        .HasForeignKey("WorkorderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderAuditLog", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.ApplicationUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("User");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderCategories", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Category", "Category")
+                        .WithMany("WorkOrderCategories")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany("WorkOrderCategories")
+                        .HasForeignKey("WorkorderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Category");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderContacts", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Contacts", "POC")
+                        .WithMany("WorkOrderContacts")
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany("WorkOrderContacts")
+                        .HasForeignKey("WorkorderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("POC");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderFieldLock", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany("FieldLocks")
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("Data.SeaHavenIndustries.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Accounts", b =>
+                {
+                    b.Navigation("Addresses");
+
+                    b.Navigation("Contacts");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.ApplicationUser", b =>
+                {
+                    b.Navigation("Templates");
+
+                    b.Navigation("WorkOrders");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Assets", b =>
+                {
+                    b.Navigation("PMSchedules");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Category", b =>
+                {
+                    b.Navigation("Templates");
+
+                    b.Navigation("WorkOrderCategories");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Contacts", b =>
+                {
+                    b.Navigation("WorkOrderContacts");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Department", b =>
+                {
+                    b.Navigation("Employees");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Dispatch", b =>
+                {
+                    b.Navigation("ChecklistItems");
+
+                    b.Navigation("Comments");
+
+                    b.Navigation("DispatchWorkOrders");
+
+                    b.Navigation("Signoffs");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Employee", b =>
+                {
+                    b.Navigation("Address");
+
+                    b.Navigation("Emails");
+
+                    b.Navigation("Phones");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.JobTitle", b =>
+                {
+                    b.Navigation("Employees");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Locations", b =>
+                {
+                    b.Navigation("Templates");
+
+                    b.Navigation("workOrders");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Quotes", b =>
+                {
+                    b.Navigation("LineItems");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Region", b =>
+                {
+                    b.Navigation("Employees");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.TaskListTemplate", b =>
+                {
+                    b.Navigation("Items");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Vendor", b =>
+                {
+                    b.Navigation("Dispatches");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrder", b =>
+                {
+                    b.Navigation("Comments");
+
+                    b.Navigation("Dispatches");
+
+                    b.Navigation("FieldLocks");
+
+                    b.Navigation("Quotes");
+
+                    b.Navigation("WorkOrderCategories");
+
+                    b.Navigation("WorkOrderContacts");
+
+                    b.Navigation("workOrderAttachments");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Data.SeaHavenIndustries/Migrations/20260624163145_Phase0_DomainFoundation.cs b/Data.SeaHavenIndustries/Migrations/20260624163145_Phase0_DomainFoundation.cs
new file mode 100644
index 0000000..13f64da
--- /dev/null
+++ b/Data.SeaHavenIndustries/Migrations/20260624163145_Phase0_DomainFoundation.cs
@@ -0,0 +1,744 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Data.SeaHavenIndustries.Migrations
+{
+    /// <inheritdoc />
+    public partial class Phase0_DomainFoundation : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Dispatches_workOrders_WorkOrderId",
+                table: "Dispatches");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_Locations_Accounts_AccountId",
+                table: "Locations");
+
+            migrationBuilder.DropIndex(
+                name: "IX_Locations_AccountId",
+                table: "Locations");
+
+            migrationBuilder.DropColumn(
+                name: "CreatedDate",
+                table: "Regions");
+
+            migrationBuilder.DropColumn(
+                name: "DeleterUserId",
+                table: "Regions");
+
+            migrationBuilder.DropColumn(
+                name: "DeletionTime",
+                table: "Regions");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "Regions");
+
+            migrationBuilder.DropColumn(
+                name: "LastModificationTime",
+                table: "Regions");
+
+            migrationBuilder.DropColumn(
+                name: "LastModifierUserId",
+                table: "Regions");
+
+            migrationBuilder.DropColumn(
+                name: "createdby",
+                table: "Regions");
+
+            migrationBuilder.DropColumn(
+                name: "AccountId",
+                table: "Locations");
+
+            migrationBuilder.DropColumn(
+                name: "CreatedDate",
+                table: "JobTitles");
+
+            migrationBuilder.DropColumn(
+                name: "DeleterUserId",
+                table: "JobTitles");
+
+            migrationBuilder.DropColumn(
+                name: "DeletionTime",
+                table: "JobTitles");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "JobTitles");
+
+            migrationBuilder.DropColumn(
+                name: "LastModificationTime",
+                table: "JobTitles");
+
+            migrationBuilder.DropColumn(
+                name: "LastModifierUserId",
+                table: "JobTitles");
+
+            migrationBuilder.DropColumn(
+                name: "createdby",
+                table: "JobTitles");
+
+            migrationBuilder.DropColumn(
+                name: "CreatedDate",
+                table: "EmployeeEmails");
+
+            migrationBuilder.DropColumn(
+                name: "DeleterUserId",
+                table: "EmployeeEmails");
+
+            migrationBuilder.DropColumn(
+                name: "DeletionTime",
+                table: "EmployeeEmails");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "EmployeeEmails");
+
+            migrationBuilder.DropColumn(
+                name: "LastModificationTime",
+                table: "EmployeeEmails");
+
+            migrationBuilder.DropColumn(
+                name: "LastModifierUserId",
+                table: "EmployeeEmails");
+
+            migrationBuilder.DropColumn(
+                name: "createdby",
+                table: "EmployeeEmails");
+
+            migrationBuilder.DropColumn(
+                name: "CreatedDate",
+                table: "Departments");
+
+            migrationBuilder.DropColumn(
+                name: "DeleterUserId",
+                table: "Departments");
+
+            migrationBuilder.DropColumn(
+                name: "DeletionTime",
+                table: "Departments");
+
+            migrationBuilder.DropColumn(
+                name: "IsDeleted",
+                table: "Departments");
+
+            migrationBuilder.DropColumn(
+                name: "LastModificationTime",
+                table: "Departments");
+
+            migrationBuilder.DropColumn(
+                name: "LastModifierUserId",
+                table: "Departments");
+
+            migrationBuilder.DropColumn(
+                name: "createdby",
+                table: "Departments");
+
+            migrationBuilder.RenameColumn(
+                name: "ZipCode",
+                table: "Locations",
+                newName: "Zip");
+
+            migrationBuilder.RenameColumn(
+                name: "Phone",
+                table: "Locations",
+                newName: "PhoneNumber");
+
+            migrationBuilder.RenameColumn(
+                name: "ContactEmail",
+                table: "Locations",
+                newName: "Email");
+
+            migrationBuilder.RenameColumn(
+                name: "Contact",
+                table: "Locations",
+                newName: "Address2");
+
+            migrationBuilder.RenameColumn(
+                name: "Address",
+                table: "Locations",
+                newName: "Address1");
+
+            migrationBuilder.AddColumn<DateOnly>(
+                name: "AssignDate",
+                table: "workOrders",
+                type: "date",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "AvettaTask",
+                table: "workOrders",
+                type: "nvarchar(max)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "CarriedOver",
+                table: "workOrders",
+                type: "int",
+                nullable: false,
+                defaultValue: 0);
+
+            migrationBuilder.AddColumn<int>(
+                name: "DocStatus",
+                table: "workOrders",
+                type: "int",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "LegacyStatus",
+                table: "workOrders",
+                type: "nvarchar(max)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "LifecycleStatus",
+                table: "workOrders",
+                type: "int",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "OperationalFlags",
+                table: "workOrders",
+                type: "int",
+                nullable: false,
+                defaultValue: 0);
+
+            migrationBuilder.AddColumn<DateOnly>(
+                name: "OriginalDate",
+                table: "workOrders",
+                type: "date",
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateOnly>(
+                name: "OriginalWeek",
+                table: "workOrders",
+                type: "date",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "PrimaryDispatchId",
+                table: "workOrders",
+                type: "int",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "RescheduleCount",
+                table: "workOrders",
+                type: "int",
+                nullable: false,
+                defaultValue: 0);
+
+            migrationBuilder.AddColumn<byte[]>(
+                name: "RowVersion",
+                table: "workOrders",
+                type: "rowversion",
+                rowVersion: true,
+                nullable: true);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "ScheduleWeekOnly",
+                table: "workOrders",
+                type: "bit",
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "ScheduledEnd",
+                table: "workOrders",
+                type: "datetime2",
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateOnly>(
+                name: "TargetWeek",
+                table: "workOrders",
+                type: "date",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "WorkOrderType",
+                table: "workOrders",
+                type: "int",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "Service",
+                table: "workOrders",
+                type: "nvarchar(128)",
+                maxLength: 128,
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "Notes",
+                table: "WorkOrderContacts",
+                type: "nvarchar(max)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "ActorType",
+                table: "WorkOrderAuditLogs",
+                type: "nvarchar(max)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "CorrelationId",
+                table: "WorkOrderAuditLogs",
+                type: "nvarchar(max)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "DispatchId",
+                table: "WorkOrderAuditLogs",
+                type: "int",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "EventType",
+                table: "WorkOrderAuditLogs",
+                type: "nvarchar(max)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<byte[]>(
+                name: "RowVersion",
+                table: "Dispatches",
+                type: "rowversion",
+                rowVersion: true,
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "Color",
+                table: "AspNetUsers",
+                type: "nvarchar(max)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "Initials",
+                table: "AspNetUsers",
+                type: "nvarchar(max)",
+                nullable: true);
+
+            migrationBuilder.CreateTable(
+                name: "WorkOrderFieldLocks",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    WorkOrderId = table.Column<int>(type: "int", nullable: false),
+                    FieldName = table.Column<string>(type: "nvarchar(450)", nullable: false),
+                    LockedAt = table.Column<DateTime>(type: "datetime2", nullable: false),
+                    LockedByUserId = table.Column<string>(type: "nvarchar(max)", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_WorkOrderFieldLocks", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_WorkOrderFieldLocks_workOrders_WorkOrderId",
+                        column: x => x.WorkOrderId,
+                        principalTable: "workOrders",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_workOrders_PrimaryDispatchId",
+                table: "workOrders",
+                column: "PrimaryDispatchId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_WorkOrderFieldLocks_WorkOrderId_FieldName",
+                table: "WorkOrderFieldLocks",
+                columns: new[] { "WorkOrderId", "FieldName" },
+                unique: true);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Dispatches_workOrders_WorkOrderId",
+                table: "Dispatches",
+                column: "WorkOrderId",
+                principalTable: "workOrders",
+                principalColumn: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_workOrders_Dispatches_PrimaryDispatchId",
+                table: "workOrders",
+                column: "PrimaryDispatchId",
+                principalTable: "Dispatches",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Restrict);
+
+            migrationBuilder.Sql("""
+                UPDATE workOrders SET LegacyStatus = Status WHERE LegacyStatus IS NULL AND Status IS NOT NULL;
+                """);
+
+            migrationBuilder.Sql("""
+                UPDATE workOrders SET LifecycleStatus = CASE
+                    WHEN LOWER(LTRIM(RTRIM(Status))) IN ('open', 'incomplete') THEN 1
+                    WHEN LOWER(LTRIM(RTRIM(Status))) IN ('pending', 'onhold', 'on hold') THEN 2
+                    WHEN LOWER(LTRIM(RTRIM(Status))) IN ('scheduled') THEN 3
+                    WHEN LOWER(LTRIM(RTRIM(Status))) IN ('en route', 'enroute') THEN 4
+                    WHEN LOWER(LTRIM(RTRIM(Status))) IN ('on site', 'onsite') THEN 5
+                    WHEN LOWER(LTRIM(RTRIM(Status))) IN ('inprogress', 'in progress') THEN 6
+                    WHEN LOWER(LTRIM(RTRIM(Status))) IN ('completed', 'complete', 'done', 'closed') THEN 7
+                    WHEN LOWER(LTRIM(RTRIM(Status))) IN ('rescheduled') THEN 8
+                    WHEN LOWER(LTRIM(RTRIM(Status))) IN ('cancelled', 'canceled') THEN 9
+                    WHEN LOWER(LTRIM(RTRIM(Status))) IN ('pending quote', 'pendingquote', 'pendingapproval', 'pending approval') THEN 10
+                    ELSE 1
+                END
+                WHERE LifecycleStatus IS NULL AND Status IS NOT NULL;
+                """);
+
+            migrationBuilder.Sql("""
+                UPDATE wo SET wo.PrimaryDispatchId = latest.DispatchId
+                FROM workOrders wo
+                INNER JOIN (
+                    SELECT WorkOrderId, MAX(Id) AS DispatchId
+                    FROM Dispatches
+                    WHERE WorkOrderId IS NOT NULL
+                    GROUP BY WorkOrderId
+                ) latest ON wo.Id = latest.WorkOrderId
+                WHERE wo.PrimaryDispatchId IS NULL;
+                """);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Dispatches_workOrders_WorkOrderId",
+                table: "Dispatches");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_workOrders_Dispatches_PrimaryDispatchId",
+                table: "workOrders");
+
+            migrationBuilder.DropTable(
+                name: "WorkOrderFieldLocks");
+
+            migrationBuilder.DropIndex(
+                name: "IX_workOrders_PrimaryDispatchId",
+                table: "workOrders");
+
+            migrationBuilder.DropColumn(
+                name: "AssignDate",
+                table: "workOrders");
+
+            migrationBuilder.DropColumn(
+                name: "AvettaTask",
+                table: "workOrders");
+
+            migrationBuilder.DropColumn(
+                name: "CarriedOver",
+                table: "workOrders");
+
+            migrationBuilder.DropColumn(
+                name: "DocStatus",
+                table: "workOrders");
+
+            migrationBuilder.DropColumn(
+                name: "LegacyStatus",
+                table: "workOrders");
+
+            migrationBuilder.DropColumn(
+                name: "LifecycleStatus",
+                table: "workOrders");
+
+            migrationBuilder.DropColumn(
+                name: "OperationalFlags",
+                table: "workOrders");
+
+            migrationBuilder.DropColumn(
+                name: "OriginalDate",
+                table: "workOrders");
+
+            migrationBuilder.DropColumn(
+                name: "OriginalWeek",
+                table: "workOrders");
+
+            migrationBuilder.DropColumn(
+                name: "PrimaryDispatchId",
+                table: "workOrders");
+
+            migrationBuilder.DropColumn(
+                name: "RescheduleCount",
+                table: "workOrders");
+
+            migrationBuilder.DropColumn(
+                name: "RowVersion",
+                table: "workOrders");
+
+            migrationBuilder.DropColumn(
+                name: "ScheduleWeekOnly",
+                table: "workOrders");
+
+            migrationBuilder.DropColumn(
+                name: "ScheduledEnd",
+                table: "workOrders");
+
+            migrationBuilder.DropColumn(
+                name: "TargetWeek",
+                table: "workOrders");
+
+            migrationBuilder.DropColumn(
+                name: "WorkOrderType",
+                table: "workOrders");
+
+            migrationBuilder.DropColumn(
+                name: "Service",
+                table: "workOrders");
+
+            migrationBuilder.DropColumn(
+                name: "Notes",
+                table: "WorkOrderContacts");
+
+            migrationBuilder.DropColumn(
+                name: "ActorType",
+                table: "WorkOrderAuditLogs");
+
+            migrationBuilder.DropColumn(
+                name: "CorrelationId",
+                table: "WorkOrderAuditLogs");
+
+            migrationBuilder.DropColumn(
+                name: "DispatchId",
+                table: "WorkOrderAuditLogs");
+
+            migrationBuilder.DropColumn(
+                name: "EventType",
+                table: "WorkOrderAuditLogs");
+
+            migrationBuilder.DropColumn(
+                name: "RowVersion",
+                table: "Dispatches");
+
+            migrationBuilder.DropColumn(
+                name: "Color",
+                table: "AspNetUsers");
+
+            migrationBuilder.DropColumn(
+                name: "Initials",
+                table: "AspNetUsers");
+
+            migrationBuilder.RenameColumn(
+                name: "Zip",
+                table: "Locations",
+                newName: "ZipCode");
+
+            migrationBuilder.RenameColumn(
+                name: "PhoneNumber",
+                table: "Locations",
+                newName: "Phone");
+
+            migrationBuilder.RenameColumn(
+                name: "Email",
+                table: "Locations",
+                newName: "ContactEmail");
+
+            migrationBuilder.RenameColumn(
+                name: "Address2",
+                table: "Locations",
+                newName: "Contact");
+
+            migrationBuilder.RenameColumn(
+                name: "Address1",
+                table: "Locations",
+                newName: "Address");
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "CreatedDate",
+                table: "Regions",
+                type: "datetime2",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "DeleterUserId",
+                table: "Regions",
+                type: "nvarchar(max)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "DeletionTime",
+                table: "Regions",
+                type: "datetime2",
+                nullable: true);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "Regions",
+                type: "bit",
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "LastModificationTime",
+                table: "Regions",
+                type: "datetime2",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "LastModifierUserId",
+                table: "Regions",
+                type: "int",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "createdby",
+                table: "Regions",
+                type: "nvarchar(max)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "AccountId",
+                table: "Locations",
+                type: "int",
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "CreatedDate",
+                table: "JobTitles",
+                type: "datetime2",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "DeleterUserId",
+                table: "JobTitles",
+                type: "nvarchar(max)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "DeletionTime",
+                table: "JobTitles",
+                type: "datetime2",
+                nullable: true);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "JobTitles",
+                type: "bit",
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "LastModificationTime",
+                table: "JobTitles",
+                type: "datetime2",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "LastModifierUserId",
+                table: "JobTitles",
+                type: "int",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "createdby",
+                table: "JobTitles",
+                type: "nvarchar(max)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "CreatedDate",
+                table: "EmployeeEmails",
+                type: "datetime2",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "DeleterUserId",
+                table: "EmployeeEmails",
+                type: "nvarchar(max)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "DeletionTime",
+                table: "EmployeeEmails",
+                type: "datetime2",
+                nullable: true);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "EmployeeEmails",
+                type: "bit",
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "LastModificationTime",
+                table: "EmployeeEmails",
+                type: "datetime2",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "LastModifierUserId",
+                table: "EmployeeEmails",
+                type: "int",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "createdby",
+                table: "EmployeeEmails",
+                type: "nvarchar(max)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "CreatedDate",
+                table: "Departments",
+                type: "datetime2",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "DeleterUserId",
+                table: "Departments",
+                type: "nvarchar(max)",
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "DeletionTime",
+                table: "Departments",
+                type: "datetime2",
+                nullable: true);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "IsDeleted",
+                table: "Departments",
+                type: "bit",
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "LastModificationTime",
+                table: "Departments",
+                type: "datetime2",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "LastModifierUserId",
+                table: "Departments",
+                type: "int",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "createdby",
+                table: "Departments",
+                type: "nvarchar(max)",
+                nullable: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Locations_AccountId",
+                table: "Locations",
+                column: "AccountId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Dispatches_workOrders_WorkOrderId",
+                table: "Dispatches",
+                column: "WorkOrderId",
+                principalTable: "workOrders",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Restrict);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Locations_Accounts_AccountId",
+                table: "Locations",
+                column: "AccountId",
+                principalTable: "Accounts",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Restrict);
+        }
+    }
+}
diff --git a/Data.SeaHavenIndustries/Migrations/20260624200000_Phase4_SearchIndexes.Designer.cs b/Data.SeaHavenIndustries/Migrations/20260624200000_Phase4_SearchIndexes.Designer.cs
new file mode 100644
index 0000000..ee0a600
--- /dev/null
+++ b/Data.SeaHavenIndustries/Migrations/20260624200000_Phase4_SearchIndexes.Designer.cs
@@ -0,0 +1,3006 @@
+// <auto-generated />
+using System;
+using Data.SeaHavenIndustries;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace Data.SeaHavenIndustries.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20260624200000_Phase4_SearchIndexes")]
+    partial class Phase4_SearchIndexes
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.8")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Accounts", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("About")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CurrencyCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FacebookUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("Importance")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("IndustryId")
+                        .HasColumnType("int");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("LinkedInUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("OwnerEmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PrivacySetting")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ServiceInstructions")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Tags")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("TerritoryId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("TimeZone")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("TwitterUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Type")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Website")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Accounts");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Addresses", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("AccountId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Address1")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Address2")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("AddressType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("City")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Country")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("County")
+                        .HasColumnType("nvarchar(max)");
+
+                    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<string>("State")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Zip")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("ContactId");
+
+                    b.ToTable("Addresses");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.ApplicationUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Color")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Contact")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("FirstName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Initials")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Locations")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("bit");
+
+                    b.Property<int?>("Type")
+                        .HasColumnType("int");
+
+                    b.Property<string>("UniqueName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserImage")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex")
+                        .HasFilter("[NormalizedUserName] IS NOT NULL");
+
+                    b.ToTable("AspNetUsers", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Assets", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("AccountId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("AssetCode")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    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<int?>("LocationId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("LocationId");
+
+                    b.ToTable("Assets");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Category", 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<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Categories");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Comments", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("CommentType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Commenter")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Commenttext")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("DispatchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Documents")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ExternalCommentId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RecordType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<int?>("WorkerOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DispatchId");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("WorkerOrderId");
+
+                    b.ToTable("Comments");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.ContactDetails", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("About")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DateOfBirth")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("FacebookUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Gender")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("LinkedInUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PrivacySetting")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Tags")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Territory")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("TwitterUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContactId");
+
+                    b.ToTable("ContactDetails");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Contacts", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("AccountId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Address1")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Address2")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("City")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ContactType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FacebookUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FirstName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("LinkedInUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("LocationId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("MiddleName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("State")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("TwitterUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Zip")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("LocationId");
+
+                    b.ToTable("Contacts");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Department", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Departments");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Dispatch", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AcceptToken")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("AcknowledgedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("CompletedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DispatchNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DispatchedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<bool>("EmailSent")
+                        .HasColumnType("bit");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("NTEAmount")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("PONumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ReplyToAddress")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<byte[]>("RowVersion")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("rowversion");
+
+                    b.Property<DateTime?>("ScheduledDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("VerifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("VerifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("Dispatches");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.DispatchChecklistItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime?>("CompletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CompletedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("DispatchId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsCompleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("ItemText")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DispatchId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("DispatchChecklistItems");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.DispatchSignoff", 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<int>("DispatchId")
+                        .HasColumnType("int");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Signature")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SignatureMethod")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("SignedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("SignoffType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DispatchId");
+
+                    b.ToTable("DispatchSignoffs");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.DispatchUpliftRequest", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<decimal?>("CurrentNTE")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<DateTime?>("DecidedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DecidedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DecisionNote")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("DispatchId")
+                        .HasColumnType("int");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RequestedByVendorName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<decimal>("RequestedNTE")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("RequiredTier")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("nvarchar(20)");
+
+                    b.Property<string>("VendorReason")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DispatchId", "Status")
+                        .IsUnique()
+                        .HasFilter("[Status] = 'Pending'");
+
+                    b.ToTable("DispatchUpliftRequests");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.DispatchWorkOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("DispatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DispatchId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("DispatchWorkOrders");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.DropdownOption", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("ParentValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("DropdownOptions");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Employee", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("About")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool?>("CanChangeProviderNumber")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("ConfirmUserName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DateOfBirth")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("DepartmentId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EmployeeNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FacebookUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("Gender")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("HireDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<int?>("JobTitleId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("LastLogin")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("LastName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("LinkedInUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("MiddleName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("PermissionGroupId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("RegionId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SMSAddress")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("TimeZone")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("TwitterUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Website")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DepartmentId");
+
+                    b.HasIndex("JobTitleId");
+
+                    b.HasIndex("RegionId");
+
+                    b.ToTable("Employees");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.EmployeeAddress", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("City")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("CountryCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("CountyId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("StateCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Street")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("StreetLineTwo")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Zip")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmployeeId")
+                        .IsUnique();
+
+                    b.ToTable("EmployeeAddresses");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.EmployeeEmail", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Address")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<int?>("EmailTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<bool?>("IsPrimary")
+                        .HasColumnType("bit");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.ToTable("EmployeeEmails");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.EmployeePhone", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Extension")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool?>("IsPrimary")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Number")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("PhoneTypeId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.ToTable("EmployeePhones");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.FollowUps", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("AccountId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("LocationId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("ScheduleDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<TimeSpan>("ScheduleStartTime")
+                        .HasColumnType("time");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("FollowUps");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.ForgetPasswordCode", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ForgetPasswordCodes");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.JobTitle", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("JobTitles");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Locations", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Address1")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Address2")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("City")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Latitude")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Longitude")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("State")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Zip")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Locations");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.PMSchedules", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("AssetId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Frequency")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    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<int?>("LocationId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("StartDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.HasIndex("LocationId");
+
+                    b.ToTable("PMSchedules");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Quotes", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("BillingAddress")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("Date")
+                        .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<string>("PO")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ProjectName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("QuotId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ShippingAddress")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SiteId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SiteName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("TT")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("WorkorderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContactId");
+
+                    b.HasIndex("WorkorderId");
+
+                    b.ToTable("Quotes");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.QuotesLineItems", 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<string>("Descriptions")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("Lineitem")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int?>("LineitemNumber")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("QuoteId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("QuoteId");
+
+                    b.ToTable("QuotesLines");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Region", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Regions");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.TaskListTemplate", 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<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    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")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("TaskListTemplates");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.TaskListTemplateItem", 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<string>("ItemText")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TaskListTemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TaskListTemplateId");
+
+                    b.ToTable("TaskListTemplateItems");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Template", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AfterPhotoAttachment")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("AfterPhotoIssue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("AssignTo")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Attachments")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BeforPhotoAttachment")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BeforPhotoIssue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("CategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DueDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("LocationId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PO")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Priority")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SignOffAttachment")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SignOffName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SignOffSignature")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("TT")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("WorkerOrderNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("WorkerOrderTitle")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssignTo");
+
+                    b.HasIndex("CategoryId");
+
+                    b.HasIndex("ContactId");
+
+                    b.HasIndex("LocationId");
+
+                    b.ToTable("Templates");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Vendor", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Address")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("City")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("CompanyName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ContactName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    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>("Phone")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("State")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("TradeSpecialties")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Zip")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Vendors");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.VendorAccessToken", 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<DateTime>("ExpiresAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime>("IssuedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("LastUsedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("RevokedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Token")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("nvarchar(64)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Token")
+                        .IsUnique();
+
+                    b.HasIndex("VendorId");
+
+                    b.ToTable("VendorAccessTokens");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AfterPhotoAttachment")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("AfterPhotoIssue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateOnly?>("AssignDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("AssignTo")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Attachments")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("AvettaTask")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BeforPhotoAttachment")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BeforPhotoIssue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Building")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("CarriedOver")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("CompletedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Customer")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DateReported")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("DocStatus")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("DueDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("ExternalWorkOrderId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalWONumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("LegacyStatus")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("LifecycleStatus")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("LocationId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("OperationalFlags")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly?>("OriginalDate")
+                        .HasColumnType("date");
+
+                    b.Property<DateOnly?>("OriginalWeek")
+                        .HasColumnType("date");
+
+                    b.Property<string>("PO")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("PrimaryDispatchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Priority")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Problem")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("RescheduleCount")
+                        .HasColumnType("int");
+
+                    b.Property<byte[]>("RowVersion")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("rowversion");
+
+                    b.Property<bool?>("ScheduleWeekOnly")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("ScheduledDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ScheduledEnd")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ScheduledStart")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Severity")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Service")
+                        .HasMaxLength(128)
+                        .HasColumnType("nvarchar(128)");
+
+                    b.Property<string>("SignOffAttachment")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SignOffName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SignOffSignature")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SiteCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Source")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SourceEmailS3Key")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SubTrade")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("TT")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateOnly?>("TargetWeek")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Trade")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<decimal?>("VendorNTE")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int?>("WorkOrderType")
+                        .HasColumnType("int");
+
+                    b.Property<string>("WorkerOrderNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("WorkerOrderTitle")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool?>("istemplate")
+                        .HasColumnType("bit");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssignTo");
+
+                    b.HasIndex("AssignTo", "ScheduledDate");
+
+                    b.HasIndex("InternalWONumber")
+                        .HasFilter("[istemplate] = 0");
+
+                    b.HasIndex("LifecycleStatus", "ScheduledDate")
+                        .HasFilter("[istemplate] = 0");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("PrimaryDispatchId");
+
+                    b.HasIndex("ScheduledDate");
+
+                    b.HasIndex("SiteCode")
+                        .HasFilter("[istemplate] = 0");
+
+                    b.HasIndex("WorkOrderType");
+
+                    b.ToTable("workOrders");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderAttachments", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Attachments")
+                        .HasColumnType("nvarchar(max)");
+
+                    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?>("WorkorderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorkorderId");
+
+                    b.ToTable("workOrderAttachments");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderAuditLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Action")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ActorType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("CorrelationId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("DispatchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EventType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FieldName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("NewValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("OldValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("WorkOrderAuditLogs");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderCategories", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("CategoryId")
+                        .HasColumnType("int");
+
+                    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?>("WorkorderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CategoryId");
+
+                    b.HasIndex("WorkorderId");
+
+                    b.ToTable("workOrderCategories");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderContacts", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("ContactId")
+                        .HasColumnType("int");
+
+                    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<string>("Notes")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("WorkorderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContactId");
+
+                    b.HasIndex("WorkorderId");
+
+                    b.ToTable("WorkOrderContacts");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderFieldLock", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("FieldName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<DateTime>("LockedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LockedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorkOrderId", "FieldName")
+                        .IsUnique();
+
+                    b.ToTable("WorkOrderFieldLocks");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex")
+                        .HasFilter("[NormalizedName] IS NOT NULL");
+
+                    b.ToTable("AspNetRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("RoleId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Addresses", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Accounts", "Account")
+                        .WithMany("Addresses")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Contacts", "Contact")
+                        .WithMany()
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Account");
+
+                    b.Navigation("Contact");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Assets", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Accounts", "Account")
+                        .WithMany()
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Locations", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Account");
+
+                    b.Navigation("Location");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Comments", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Dispatch", "Dispatch")
+                        .WithMany("Comments")
+                        .HasForeignKey("DispatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.ApplicationUser", "ApplicationUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany("Comments")
+                        .HasForeignKey("WorkerOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("ApplicationUser");
+
+                    b.Navigation("Dispatch");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.ContactDetails", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Contacts", "Contact")
+                        .WithMany()
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Contact");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Contacts", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Accounts", "Account")
+                        .WithMany("Contacts")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Locations", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Account");
+
+                    b.Navigation("Location");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Dispatch", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Vendor", "Vendor")
+                        .WithMany("Dispatches")
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany("Dispatches")
+                        .HasForeignKey("WorkOrderId");
+
+                    b.Navigation("Vendor");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.DispatchChecklistItem", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Dispatch", "Dispatch")
+                        .WithMany("ChecklistItems")
+                        .HasForeignKey("DispatchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Dispatch");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.DispatchSignoff", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Dispatch", "Dispatch")
+                        .WithMany("Signoffs")
+                        .HasForeignKey("DispatchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Dispatch");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.DispatchUpliftRequest", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Dispatch", "Dispatch")
+                        .WithMany()
+                        .HasForeignKey("DispatchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Dispatch");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.DispatchWorkOrder", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Dispatch", "Dispatch")
+                        .WithMany("DispatchWorkOrders")
+                        .HasForeignKey("DispatchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Dispatch");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Employee", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Department", "Department")
+                        .WithMany("Employees")
+                        .HasForeignKey("DepartmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.JobTitle", "JobTitle")
+                        .WithMany("Employees")
+                        .HasForeignKey("JobTitleId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Region", "Region")
+                        .WithMany("Employees")
+                        .HasForeignKey("RegionId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Department");
+
+                    b.Navigation("JobTitle");
+
+                    b.Navigation("Region");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.EmployeeAddress", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Employee", "Employee")
+                        .WithOne("Address")
+                        .HasForeignKey("Data.SeaHavenIndustries.EmployeeAddress", "EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.EmployeeEmail", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Employee", "Employee")
+                        .WithMany("Emails")
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.EmployeePhone", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Employee", "Employee")
+                        .WithMany("Phones")
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.FollowUps", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Accounts", "Account")
+                        .WithMany()
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Locations", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Account");
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("Location");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.PMSchedules", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Assets", "Asset")
+                        .WithMany("PMSchedules")
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Locations", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Asset");
+
+                    b.Navigation("Location");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Quotes", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Contacts", "Contacts")
+                        .WithMany()
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany("Quotes")
+                        .HasForeignKey("WorkorderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Contacts");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.QuotesLineItems", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Quotes", "Quotes")
+                        .WithMany("LineItems")
+                        .HasForeignKey("QuoteId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Quotes");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.TaskListTemplateItem", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.TaskListTemplate", "Template")
+                        .WithMany("Items")
+                        .HasForeignKey("TaskListTemplateId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Template", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.ApplicationUser", "AssignToUser")
+                        .WithMany("Templates")
+                        .HasForeignKey("AssignTo")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Category", "Category")
+                        .WithMany("Templates")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Contacts", "POC")
+                        .WithMany()
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Locations", "Locations")
+                        .WithMany("Templates")
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("AssignToUser");
+
+                    b.Navigation("Category");
+
+                    b.Navigation("Locations");
+
+                    b.Navigation("POC");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.VendorAccessToken", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrder", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.ApplicationUser", "AssignToUser")
+                        .WithMany("WorkOrders")
+                        .HasForeignKey("AssignTo")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Locations", "Locations")
+                        .WithMany("workOrders")
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Dispatch", "PrimaryDispatch")
+                        .WithMany()
+                        .HasForeignKey("PrimaryDispatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("AssignToUser");
+
+                    b.Navigation("Locations");
+
+                    b.Navigation("PrimaryDispatch");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderAttachments", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany("workOrderAttachments")
+                        .HasForeignKey("WorkorderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderAuditLog", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.ApplicationUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("User");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderCategories", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Category", "Category")
+                        .WithMany("WorkOrderCategories")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany("WorkOrderCategories")
+                        .HasForeignKey("WorkorderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Category");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderContacts", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Contacts", "POC")
+                        .WithMany("WorkOrderContacts")
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany("WorkOrderContacts")
+                        .HasForeignKey("WorkorderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("POC");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderFieldLock", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany("FieldLocks")
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("Data.SeaHavenIndustries.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Accounts", b =>
+                {
+                    b.Navigation("Addresses");
+
+                    b.Navigation("Contacts");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.ApplicationUser", b =>
+                {
+                    b.Navigation("Templates");
+
+                    b.Navigation("WorkOrders");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Assets", b =>
+                {
+                    b.Navigation("PMSchedules");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Category", b =>
+                {
+                    b.Navigation("Templates");
+
+                    b.Navigation("WorkOrderCategories");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Contacts", b =>
+                {
+                    b.Navigation("WorkOrderContacts");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Department", b =>
+                {
+                    b.Navigation("Employees");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Dispatch", b =>
+                {
+                    b.Navigation("ChecklistItems");
+
+                    b.Navigation("Comments");
+
+                    b.Navigation("DispatchWorkOrders");
+
+                    b.Navigation("Signoffs");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Employee", b =>
+                {
+                    b.Navigation("Address");
+
+                    b.Navigation("Emails");
+
+                    b.Navigation("Phones");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.JobTitle", b =>
+                {
+                    b.Navigation("Employees");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Locations", b =>
+                {
+                    b.Navigation("Templates");
+
+                    b.Navigation("workOrders");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Quotes", b =>
+                {
+                    b.Navigation("LineItems");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Region", b =>
+                {
+                    b.Navigation("Employees");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.TaskListTemplate", b =>
+                {
+                    b.Navigation("Items");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Vendor", b =>
+                {
+                    b.Navigation("Dispatches");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrder", b =>
+                {
+                    b.Navigation("Comments");
+
+                    b.Navigation("Dispatches");
+
+                    b.Navigation("FieldLocks");
+
+                    b.Navigation("Quotes");
+
+                    b.Navigation("WorkOrderCategories");
+
+                    b.Navigation("WorkOrderContacts");
+
+                    b.Navigation("workOrderAttachments");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Data.SeaHavenIndustries/Migrations/20260624200000_Phase4_SearchIndexes.cs b/Data.SeaHavenIndustries/Migrations/20260624200000_Phase4_SearchIndexes.cs
new file mode 100644
index 0000000..51795a3
--- /dev/null
+++ b/Data.SeaHavenIndustries/Migrations/20260624200000_Phase4_SearchIndexes.cs
@@ -0,0 +1,89 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Data.SeaHavenIndustries.Migrations
+{
+    /// <inheritdoc />
+    public partial class Phase4_SearchIndexes : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            // nvarchar(max) cannot be an index key; shrink before indexing.
+            migrationBuilder.AlterColumn<string>(
+                name: "SiteCode",
+                table: "workOrders",
+                type: "nvarchar(450)",
+                maxLength: 450,
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "InternalWONumber",
+                table: "workOrders",
+                type: "nvarchar(450)",
+                maxLength: 450,
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(max)",
+                oldNullable: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_workOrders_SiteCode",
+                table: "workOrders",
+                column: "SiteCode",
+                filter: "[istemplate] = 0");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_workOrders_InternalWONumber",
+                table: "workOrders",
+                column: "InternalWONumber",
+                filter: "[istemplate] = 0");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_workOrders_LifecycleStatus_ScheduledDate",
+                table: "workOrders",
+                columns: new[] { "LifecycleStatus", "ScheduledDate" },
+                filter: "[istemplate] = 0");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropIndex(
+                name: "IX_workOrders_SiteCode",
+                table: "workOrders");
+
+            migrationBuilder.DropIndex(
+                name: "IX_workOrders_InternalWONumber",
+                table: "workOrders");
+
+            migrationBuilder.DropIndex(
+                name: "IX_workOrders_LifecycleStatus_ScheduledDate",
+                table: "workOrders");
+
+            migrationBuilder.AlterColumn<string>(
+                name: "SiteCode",
+                table: "workOrders",
+                type: "nvarchar(max)",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(450)",
+                oldMaxLength: 450,
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<string>(
+                name: "InternalWONumber",
+                table: "workOrders",
+                type: "nvarchar(max)",
+                nullable: true,
+                oldClrType: typeof(string),
+                oldType: "nvarchar(450)",
+                oldMaxLength: 450,
+                oldNullable: true);
+        }
+    }
+}
diff --git a/Data.SeaHavenIndustries/Migrations/20260625120000_Phase6_CompletionSlideOver.cs b/Data.SeaHavenIndustries/Migrations/20260625120000_Phase6_CompletionSlideOver.cs
new file mode 100644
index 0000000..f52940d
--- /dev/null
+++ b/Data.SeaHavenIndustries/Migrations/20260625120000_Phase6_CompletionSlideOver.cs
@@ -0,0 +1,88 @@
+using Data.SeaHavenIndustries;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Data.SeaHavenIndustries.Migrations
+{
+    /// <inheritdoc />
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20260625120000_Phase6_CompletionSlideOver")]
+    public partial class Phase6_CompletionSlideOver : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.Sql(@"
+                IF COL_LENGTH('workOrderAttachments', 'Category') IS NULL
+                BEGIN
+                    ALTER TABLE workOrderAttachments ADD Category int NULL;
+                END
+            ");
+
+            migrationBuilder.Sql(@"
+                IF OBJECT_ID(N'dbo.CompletionDocTemplates', N'U') IS NULL
+                BEGIN
+                    CREATE TABLE CompletionDocTemplates (
+                        Id int NOT NULL IDENTITY(1,1),
+                        Name nvarchar(max) NOT NULL,
+                        ServiceKey nvarchar(450) NOT NULL,
+                        WorkOrderType int 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,
+                        CONSTRAINT PK_CompletionDocTemplates PRIMARY KEY (Id)
+                    );
+                END
+            ");
+
+            migrationBuilder.Sql(@"
+                IF NOT EXISTS (
+                    SELECT 1 FROM sys.indexes
+                    WHERE name = N'IX_CompletionDocTemplates_ServiceKey_IsActive'
+                      AND object_id = OBJECT_ID(N'dbo.CompletionDocTemplates'))
+                BEGIN
+                    CREATE INDEX IX_CompletionDocTemplates_ServiceKey_IsActive
+                        ON CompletionDocTemplates (ServiceKey, IsActive);
+                END
+            ");
+
+            migrationBuilder.Sql(@"
+                UPDATE workOrders
+                SET DocStatus = 1
+                WHERE DocStatus IS NULL
+                  AND SignOffAttachment IS NOT NULL
+                  AND LTRIM(RTRIM(SignOffAttachment)) <> '';
+            ");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.Sql(@"
+                UPDATE workOrders
+                SET DocStatus = NULL
+                WHERE DocStatus = 1
+                  AND SignOffAttachment IS NOT NULL
+                  AND LTRIM(RTRIM(SignOffAttachment)) <> '';
+            ");
+
+            migrationBuilder.Sql(@"
+                IF OBJECT_ID(N'dbo.CompletionDocTemplates', N'U') IS NOT NULL
+                    DROP TABLE CompletionDocTemplates;
+            ");
+
+            migrationBuilder.Sql(@"
+                IF COL_LENGTH('workOrderAttachments', 'Category') IS NOT NULL
+                    ALTER TABLE workOrderAttachments DROP COLUMN Category;
+            ");
+        }
+    }
+}
diff --git a/Data.SeaHavenIndustries/Migrations/20260701120000_Phase1_BoardIndexes.cs b/Data.SeaHavenIndustries/Migrations/20260701120000_Phase1_BoardIndexes.cs
new file mode 100644
index 0000000..23968a8
--- /dev/null
+++ b/Data.SeaHavenIndustries/Migrations/20260701120000_Phase1_BoardIndexes.cs
@@ -0,0 +1,64 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Data.SeaHavenIndustries.Migrations
+{
+    /// <inheritdoc />
+    public class Phase1_BoardIndexes : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.Sql("""
+                IF NOT EXISTS (
+                    SELECT 1 FROM sys.indexes
+                    WHERE name = 'IX_workOrders_ScheduledDate'
+                      AND object_id = OBJECT_ID('workOrders'))
+                BEGIN
+                    CREATE INDEX IX_workOrders_ScheduledDate ON workOrders (ScheduledDate);
+                END
+
+                IF NOT EXISTS (
+                    SELECT 1 FROM sys.indexes
+                    WHERE name = 'IX_workOrders_AssignTo_ScheduledDate'
+                      AND object_id = OBJECT_ID('workOrders'))
+                BEGIN
+                    CREATE INDEX IX_workOrders_AssignTo_ScheduledDate ON workOrders (AssignTo, ScheduledDate);
+                END
+
+                IF NOT EXISTS (
+                    SELECT 1 FROM sys.indexes
+                    WHERE name = 'IX_workOrders_WorkOrderType'
+                      AND object_id = OBJECT_ID('workOrders'))
+                BEGIN
+                    CREATE INDEX IX_workOrders_WorkOrderType ON workOrders (WorkOrderType);
+                END
+                """);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.Sql("""
+                IF EXISTS (
+                    SELECT 1 FROM sys.indexes
+                    WHERE name = 'IX_workOrders_WorkOrderType'
+                      AND object_id = OBJECT_ID('workOrders'))
+                    DROP INDEX IX_workOrders_WorkOrderType ON workOrders;
+
+                IF EXISTS (
+                    SELECT 1 FROM sys.indexes
+                    WHERE name = 'IX_workOrders_AssignTo_ScheduledDate'
+                      AND object_id = OBJECT_ID('workOrders'))
+                    DROP INDEX IX_workOrders_AssignTo_ScheduledDate ON workOrders;
+
+                IF EXISTS (
+                    SELECT 1 FROM sys.indexes
+                    WHERE name = 'IX_workOrders_ScheduledDate'
+                      AND object_id = OBJECT_ID('workOrders'))
+                    DROP INDEX IX_workOrders_ScheduledDate ON workOrders;
+                """);
+        }
+    }
+}
diff --git a/Data.SeaHavenIndustries/Migrations/20260709170202_Phase5_DomainEvents.Designer.cs b/Data.SeaHavenIndustries/Migrations/20260709170202_Phase5_DomainEvents.Designer.cs
new file mode 100644
index 0000000..3951386
--- /dev/null
+++ b/Data.SeaHavenIndustries/Migrations/20260709170202_Phase5_DomainEvents.Designer.cs
@@ -0,0 +1,3046 @@
+// <auto-generated />
+using System;
+using Data.SeaHavenIndustries;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace Data.SeaHavenIndustries.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20260709170202_Phase5_DomainEvents")]
+    partial class Phase5_DomainEvents
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.8")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Accounts", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("About")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CurrencyCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FacebookUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("Importance")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("IndustryId")
+                        .HasColumnType("int");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("LinkedInUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("OwnerEmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PrivacySetting")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ServiceInstructions")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Tags")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("TerritoryId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("TimeZone")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("TwitterUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Type")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Website")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Accounts", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Addresses", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("AccountId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Address1")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Address2")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("AddressType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("City")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Country")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("County")
+                        .HasColumnType("nvarchar(max)");
+
+                    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<string>("State")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Zip")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("ContactId");
+
+                    b.ToTable("Addresses", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.ApplicationUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Color")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Contact")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DeletedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("FirstName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Initials")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Locations")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("bit");
+
+                    b.Property<int?>("Type")
+                        .HasColumnType("int");
+
+                    b.Property<string>("UniqueName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserImage")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex")
+                        .HasFilter("[NormalizedUserName] IS NOT NULL");
+
+                    b.ToTable("AspNetUsers", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Assets", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("AccountId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("AssetCode")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    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<int?>("LocationId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("LocationId");
+
+                    b.ToTable("Assets", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Category", 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<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Categories", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Comments", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("CommentType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Commenter")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Commenttext")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("DispatchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Documents")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ExternalCommentId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RecordType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<int?>("WorkerOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DispatchId");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("WorkerOrderId");
+
+                    b.ToTable("Comments", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.ContactDetails", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("About")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DateOfBirth")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("FacebookUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Gender")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("LinkedInUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PrivacySetting")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Tags")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Territory")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("TwitterUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContactId");
+
+                    b.ToTable("ContactDetails", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Contacts", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("AccountId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Address1")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Address2")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("City")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ContactType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FacebookUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FirstName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("LinkedInUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("LocationId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("MiddleName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("State")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("TwitterUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Zip")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("LocationId");
+
+                    b.ToTable("Contacts", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Department", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Departments", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Dispatch", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AcceptToken")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("AcknowledgedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("CompletedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DispatchNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DispatchedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<bool>("EmailSent")
+                        .HasColumnType("bit");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("NTEAmount")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("PONumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ReplyToAddress")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<byte[]>("RowVersion")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("rowversion");
+
+                    b.Property<DateTime?>("ScheduledDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("VerifiedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("VerifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("VendorId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("Dispatches", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.DispatchChecklistItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime?>("CompletedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CompletedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("DispatchId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsCompleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("ItemText")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DispatchId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("DispatchChecklistItems", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.DispatchSignoff", 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<int>("DispatchId")
+                        .HasColumnType("int");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Signature")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SignatureMethod")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("SignedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("SignoffType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DispatchId");
+
+                    b.ToTable("DispatchSignoffs", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.DispatchUpliftRequest", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<decimal?>("CurrentNTE")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<DateTime?>("DecidedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DecidedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DecisionNote")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("DispatchId")
+                        .HasColumnType("int");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RequestedByVendorName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<decimal>("RequestedNTE")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int>("RequiredTier")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("nvarchar(20)");
+
+                    b.Property<string>("VendorReason")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DispatchId", "Status")
+                        .IsUnique()
+                        .HasFilter("[Status] = 'Pending'");
+
+                    b.ToTable("DispatchUpliftRequests", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.DispatchWorkOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("DispatchId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DispatchId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("DispatchWorkOrders", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.DropdownOption", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("ParentValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("DropdownOptions", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Employee", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("About")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool?>("CanChangeProviderNumber")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("ConfirmUserName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("DateOfBirth")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("DepartmentId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EmployeeNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FacebookUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("Gender")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("HireDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<int?>("JobTitleId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("LastLogin")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("LastName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("LinkedInUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("MiddleName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("PermissionGroupId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("RegionId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SMSAddress")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("TimeZone")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("TwitterUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Website")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DepartmentId");
+
+                    b.HasIndex("JobTitleId");
+
+                    b.HasIndex("RegionId");
+
+                    b.ToTable("Employees", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.EmployeeAddress", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("City")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("CountryCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("CountyId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("StateCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Street")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("StreetLineTwo")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Zip")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmployeeId")
+                        .IsUnique();
+
+                    b.ToTable("EmployeeAddresses", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.EmployeeEmail", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Address")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<int?>("EmailTypeId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<bool?>("IsPrimary")
+                        .HasColumnType("bit");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.ToTable("EmployeeEmails", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.EmployeePhone", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Extension")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool?>("IsPrimary")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Number")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("PhoneTypeId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.ToTable("EmployeePhones", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.FollowUps", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("AccountId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("EmployeeId")
+                        .HasColumnType("int");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("LocationId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("ScheduleDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<TimeSpan>("ScheduleStartTime")
+                        .HasColumnType("time");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("EmployeeId");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("FollowUps", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.ForgetPasswordCode", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ForgetPasswordCodes", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.JobTitle", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("JobTitles", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Locations", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Address1")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Address2")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("City")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Latitude")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Longitude")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("State")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Zip")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Locations", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.PMSchedules", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("AssetId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Frequency")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    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<int?>("LocationId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("StartDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.HasIndex("LocationId");
+
+                    b.ToTable("PMSchedules", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Quotes", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("BillingAddress")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("Date")
+                        .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<string>("PO")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ProjectName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("QuotId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ShippingAddress")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SiteId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SiteName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("TT")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("WorkorderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContactId");
+
+                    b.HasIndex("WorkorderId");
+
+                    b.ToTable("Quotes", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.QuotesLineItems", 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<string>("Descriptions")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<decimal?>("Lineitem")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int?>("LineitemNumber")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("QuoteId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("QuoteId");
+
+                    b.ToTable("QuotesLines", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Region", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Regions", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.TaskListTemplate", 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<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    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")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("TaskListTemplates", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.TaskListTemplateItem", 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<string>("ItemText")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TaskListTemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TaskListTemplateId");
+
+                    b.ToTable("TaskListTemplateItems", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Template", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AfterPhotoAttachment")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("AfterPhotoIssue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("AssignTo")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Attachments")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BeforPhotoAttachment")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BeforPhotoIssue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("CategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ContactId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DueDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("LocationId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PO")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Priority")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SignOffAttachment")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SignOffName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SignOffSignature")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("TT")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("WorkerOrderNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("WorkerOrderTitle")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssignTo");
+
+                    b.HasIndex("CategoryId");
+
+                    b.HasIndex("ContactId");
+
+                    b.HasIndex("LocationId");
+
+                    b.ToTable("Templates", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Vendor", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Address")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("City")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("CompanyName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ContactName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
+                    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>("Phone")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("State")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("TradeSpecialties")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Zip")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Vendors", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.VendorAccessToken", 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<DateTime>("ExpiresAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime>("IssuedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("LastUsedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("RevokedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Token")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("nvarchar(64)");
+
+                    b.Property<int>("VendorId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Token")
+                        .IsUnique();
+
+                    b.HasIndex("VendorId");
+
+                    b.ToTable("VendorAccessTokens", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AfterPhotoAttachment")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("AfterPhotoIssue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateOnly?>("AssignDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("AssignTo")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Attachments")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("AvettaTask")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BeforPhotoAttachment")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("BeforPhotoIssue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Building")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("CarriedOver")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("CompletedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Customer")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DateReported")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("DocStatus")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("DueDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("ExternalWorkOrderId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalWONumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("LegacyStatus")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("LifecycleStatus")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("LocationId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("OperationalFlags")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly?>("OriginalDate")
+                        .HasColumnType("date");
+
+                    b.Property<DateOnly?>("OriginalWeek")
+                        .HasColumnType("date");
+
+                    b.Property<string>("PO")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("PrimaryDispatchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Priority")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Problem")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("RescheduleCount")
+                        .HasColumnType("int");
+
+                    b.Property<byte[]>("RowVersion")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("rowversion");
+
+                    b.Property<bool?>("ScheduleWeekOnly")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("ScheduledDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ScheduledEnd")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ScheduledStart")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Service")
+                        .HasMaxLength(128)
+                        .HasColumnType("nvarchar(128)");
+
+                    b.Property<string>("Severity")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SignOffAttachment")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SignOffName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SignOffSignature")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SiteCode")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Source")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SourceEmailS3Key")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SubTrade")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("TT")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateOnly?>("TargetWeek")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Trade")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<decimal?>("VendorNTE")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<int?>("WorkOrderType")
+                        .HasColumnType("int");
+
+                    b.Property<string>("WorkerOrderNumber")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("WorkerOrderTitle")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool?>("istemplate")
+                        .HasColumnType("bit");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssignTo");
+
+                    b.HasIndex("AssignTo", "ScheduledDate");
+
+                    b.HasIndex("InternalWONumber")
+                        .HasFilter("[istemplate] = 0");
+
+                    b.HasIndex("LifecycleStatus", "ScheduledDate")
+                        .HasFilter("[istemplate] = 0");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("PrimaryDispatchId");
+
+                    b.HasIndex("ScheduledDate");
+
+                    b.HasIndex("SiteCode")
+                        .HasFilter("[istemplate] = 0");
+
+                    b.HasIndex("WorkOrderType");
+
+                    b.ToTable("workOrders", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderAttachments", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Attachments")
+                        .HasColumnType("nvarchar(max)");
+
+                    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?>("WorkorderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorkorderId");
+
+                    b.ToTable("workOrderAttachments", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderAuditLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Action")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ActorType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("CorrelationId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("DispatchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EventType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FieldName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("NewValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("OldValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("WorkOrderId");
+
+                    b.ToTable("WorkOrderAuditLogs", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderCategories", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("CategoryId")
+                        .HasColumnType("int");
+
+                    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?>("WorkorderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CategoryId");
+
+                    b.HasIndex("WorkorderId");
+
+                    b.ToTable("workOrderCategories", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderContacts", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("ContactId")
+                        .HasColumnType("int");
+
+                    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<string>("Notes")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("WorkorderId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContactId");
+
+                    b.HasIndex("WorkorderId");
+
+                    b.ToTable("WorkOrderContacts", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderFieldLock", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("FieldName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<DateTime>("LockedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LockedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorkOrderId", "FieldName")
+                        .IsUnique();
+
+                    b.ToTable("WorkOrderFieldLocks", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderWeekRolledLedger", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("CorrelationId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("ProcessedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateOnly>("SourceWeekStart")
+                        .HasColumnType("date");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorkOrderId", "SourceWeekStart")
+                        .IsUnique();
+
+                    b.ToTable("WorkOrderWeekRolledLedgers", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex")
+                        .HasFilter("[NormalizedName] IS NOT NULL");
+
+                    b.ToTable("AspNetRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("RoleId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens", (string)null);
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Addresses", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Accounts", "Account")
+                        .WithMany("Addresses")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Contacts", "Contact")
+                        .WithMany()
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Account");
+
+                    b.Navigation("Contact");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Assets", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Accounts", "Account")
+                        .WithMany()
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Locations", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Account");
+
+                    b.Navigation("Location");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Comments", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Dispatch", "Dispatch")
+                        .WithMany("Comments")
+                        .HasForeignKey("DispatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.ApplicationUser", "ApplicationUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany("Comments")
+                        .HasForeignKey("WorkerOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("ApplicationUser");
+
+                    b.Navigation("Dispatch");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.ContactDetails", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Contacts", "Contact")
+                        .WithMany()
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Contact");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Contacts", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Accounts", "Account")
+                        .WithMany("Contacts")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Locations", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Account");
+
+                    b.Navigation("Location");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Dispatch", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Vendor", "Vendor")
+                        .WithMany("Dispatches")
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany("Dispatches")
+                        .HasForeignKey("WorkOrderId");
+
+                    b.Navigation("Vendor");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.DispatchChecklistItem", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Dispatch", "Dispatch")
+                        .WithMany("ChecklistItems")
+                        .HasForeignKey("DispatchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Dispatch");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.DispatchSignoff", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Dispatch", "Dispatch")
+                        .WithMany("Signoffs")
+                        .HasForeignKey("DispatchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Dispatch");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.DispatchUpliftRequest", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Dispatch", "Dispatch")
+                        .WithMany()
+                        .HasForeignKey("DispatchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Dispatch");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.DispatchWorkOrder", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Dispatch", "Dispatch")
+                        .WithMany("DispatchWorkOrders")
+                        .HasForeignKey("DispatchId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Dispatch");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Employee", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Department", "Department")
+                        .WithMany("Employees")
+                        .HasForeignKey("DepartmentId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.JobTitle", "JobTitle")
+                        .WithMany("Employees")
+                        .HasForeignKey("JobTitleId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Region", "Region")
+                        .WithMany("Employees")
+                        .HasForeignKey("RegionId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Department");
+
+                    b.Navigation("JobTitle");
+
+                    b.Navigation("Region");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.EmployeeAddress", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Employee", "Employee")
+                        .WithOne("Address")
+                        .HasForeignKey("Data.SeaHavenIndustries.EmployeeAddress", "EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.EmployeeEmail", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Employee", "Employee")
+                        .WithMany("Emails")
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.EmployeePhone", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Employee", "Employee")
+                        .WithMany("Phones")
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Employee");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.FollowUps", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Accounts", "Account")
+                        .WithMany()
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Employee", "Employee")
+                        .WithMany()
+                        .HasForeignKey("EmployeeId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Locations", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Account");
+
+                    b.Navigation("Employee");
+
+                    b.Navigation("Location");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.PMSchedules", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Assets", "Asset")
+                        .WithMany("PMSchedules")
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Locations", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Asset");
+
+                    b.Navigation("Location");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Quotes", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Contacts", "Contacts")
+                        .WithMany()
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany("Quotes")
+                        .HasForeignKey("WorkorderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Contacts");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.QuotesLineItems", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Quotes", "Quotes")
+                        .WithMany("LineItems")
+                        .HasForeignKey("QuoteId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Quotes");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.TaskListTemplateItem", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.TaskListTemplate", "Template")
+                        .WithMany("Items")
+                        .HasForeignKey("TaskListTemplateId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Template", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.ApplicationUser", "AssignToUser")
+                        .WithMany("Templates")
+                        .HasForeignKey("AssignTo")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Category", "Category")
+                        .WithMany("Templates")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Contacts", "POC")
+                        .WithMany()
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Locations", "Locations")
+                        .WithMany("Templates")
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("AssignToUser");
+
+                    b.Navigation("Category");
+
+                    b.Navigation("Locations");
+
+                    b.Navigation("POC");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.VendorAccessToken", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Vendor", "Vendor")
+                        .WithMany()
+                        .HasForeignKey("VendorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Vendor");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrder", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.ApplicationUser", "AssignToUser")
+                        .WithMany("WorkOrders")
+                        .HasForeignKey("AssignTo")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Locations", "Locations")
+                        .WithMany("workOrders")
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.Dispatch", "PrimaryDispatch")
+                        .WithMany()
+                        .HasForeignKey("PrimaryDispatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("AssignToUser");
+
+                    b.Navigation("Locations");
+
+                    b.Navigation("PrimaryDispatch");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderAttachments", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany("workOrderAttachments")
+                        .HasForeignKey("WorkorderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderAuditLog", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.ApplicationUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("User");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderCategories", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Category", "Category")
+                        .WithMany("WorkOrderCategories")
+                        .HasForeignKey("CategoryId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany("WorkOrderCategories")
+                        .HasForeignKey("WorkorderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Category");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderContacts", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.Contacts", "POC")
+                        .WithMany("WorkOrderContacts")
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany("WorkOrderContacts")
+                        .HasForeignKey("WorkorderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("POC");
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderWeekRolledLedger", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderFieldLock", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany("FieldLocks")
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("Data.SeaHavenIndustries.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Accounts", b =>
+                {
+                    b.Navigation("Addresses");
+
+                    b.Navigation("Contacts");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.ApplicationUser", b =>
+                {
+                    b.Navigation("Templates");
+
+                    b.Navigation("WorkOrders");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Assets", b =>
+                {
+                    b.Navigation("PMSchedules");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Category", b =>
+                {
+                    b.Navigation("Templates");
+
+                    b.Navigation("WorkOrderCategories");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Contacts", b =>
+                {
+                    b.Navigation("WorkOrderContacts");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Department", b =>
+                {
+                    b.Navigation("Employees");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Dispatch", b =>
+                {
+                    b.Navigation("ChecklistItems");
+
+                    b.Navigation("Comments");
+
+                    b.Navigation("DispatchWorkOrders");
+
+                    b.Navigation("Signoffs");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Employee", b =>
+                {
+                    b.Navigation("Address");
+
+                    b.Navigation("Emails");
+
+                    b.Navigation("Phones");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.JobTitle", b =>
+                {
+                    b.Navigation("Employees");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Locations", b =>
+                {
+                    b.Navigation("Templates");
+
+                    b.Navigation("workOrders");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Quotes", b =>
+                {
+                    b.Navigation("LineItems");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Region", b =>
+                {
+                    b.Navigation("Employees");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.TaskListTemplate", b =>
+                {
+                    b.Navigation("Items");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.Vendor", b =>
+                {
+                    b.Navigation("Dispatches");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrder", b =>
+                {
+                    b.Navigation("Comments");
+
+                    b.Navigation("Dispatches");
+
+                    b.Navigation("FieldLocks");
+
+                    b.Navigation("Quotes");
+
+                    b.Navigation("WorkOrderCategories");
+
+                    b.Navigation("WorkOrderContacts");
+
+                    b.Navigation("workOrderAttachments");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Data.SeaHavenIndustries/Migrations/20260709170202_Phase5_DomainEvents.cs b/Data.SeaHavenIndustries/Migrations/20260709170202_Phase5_DomainEvents.cs
new file mode 100644
index 0000000..6a0307f
--- /dev/null
+++ b/Data.SeaHavenIndustries/Migrations/20260709170202_Phase5_DomainEvents.cs
@@ -0,0 +1,50 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Data.SeaHavenIndustries.Migrations
+{
+    /// <inheritdoc />
+    public partial class Phase5_DomainEvents : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "WorkOrderWeekRolledLedgers",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    WorkOrderId = table.Column<int>(type: "int", nullable: false),
+                    SourceWeekStart = table.Column<DateOnly>(type: "date", nullable: false),
+                    ProcessedAt = table.Column<DateTime>(type: "datetime2", nullable: false),
+                    CorrelationId = table.Column<string>(type: "nvarchar(max)", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_WorkOrderWeekRolledLedgers", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_WorkOrderWeekRolledLedgers_workOrders_WorkOrderId",
+                        column: x => x.WorkOrderId,
+                        principalTable: "workOrders",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_WorkOrderWeekRolledLedgers_WorkOrderId_SourceWeekStart",
+                table: "WorkOrderWeekRolledLedgers",
+                columns: new[] { "WorkOrderId", "SourceWeekStart" },
+                unique: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "WorkOrderWeekRolledLedgers");
+        }
+    }
+}
diff --git a/Data.SeaHavenIndustries/Migrations/20260713120000_Phase7_ExternalWorkOrderIdUnique.cs b/Data.SeaHavenIndustries/Migrations/20260713120000_Phase7_ExternalWorkOrderIdUnique.cs
new file mode 100644
index 0000000..2958307
--- /dev/null
+++ b/Data.SeaHavenIndustries/Migrations/20260713120000_Phase7_ExternalWorkOrderIdUnique.cs
@@ -0,0 +1,63 @@
+using Data.SeaHavenIndustries;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Data.SeaHavenIndustries.Migrations
+{
+    /// <inheritdoc />
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20260713120000_Phase7_ExternalWorkOrderIdUnique")]
+    public partial class Phase7_ExternalWorkOrderIdUnique : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            // Idempotent: column may already be nvarchar(450) in some environments.
+            migrationBuilder.Sql(@"
+                IF COL_LENGTH('workOrders', 'ExternalWorkOrderId') IS NOT NULL
+                   AND EXISTS (
+                       SELECT 1
+                       FROM sys.columns c
+                       INNER JOIN sys.types t ON c.user_type_id = t.user_type_id
+                       WHERE c.object_id = OBJECT_ID(N'dbo.workOrders')
+                         AND c.name = N'ExternalWorkOrderId'
+                         AND t.name = N'nvarchar'
+                         AND c.max_length = -1)
+                BEGIN
+                    ALTER TABLE workOrders ALTER COLUMN ExternalWorkOrderId nvarchar(450) NULL;
+                END
+            ");
+
+            migrationBuilder.Sql(@"
+                IF NOT EXISTS (
+                    SELECT 1 FROM sys.indexes
+                    WHERE name = N'IX_workOrders_ExternalWorkOrderId'
+                      AND object_id = OBJECT_ID(N'dbo.workOrders'))
+                BEGIN
+                    CREATE UNIQUE INDEX IX_workOrders_ExternalWorkOrderId
+                        ON workOrders (ExternalWorkOrderId)
+                        WHERE [ExternalWorkOrderId] IS NOT NULL AND [ExternalWorkOrderId] <> '';
+                END
+            ");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.Sql(@"
+                IF EXISTS (
+                    SELECT 1 FROM sys.indexes
+                    WHERE name = N'IX_workOrders_ExternalWorkOrderId'
+                      AND object_id = OBJECT_ID(N'dbo.workOrders'))
+                    DROP INDEX IX_workOrders_ExternalWorkOrderId ON workOrders;
+            ");
+
+            migrationBuilder.Sql(@"
+                IF COL_LENGTH('workOrders', 'ExternalWorkOrderId') IS NOT NULL
+                    ALTER TABLE workOrders ALTER COLUMN ExternalWorkOrderId nvarchar(max) NULL;
+            ");
+        }
+    }
+}
diff --git a/Data.SeaHavenIndustries/Migrations/20260715160000_WoServiceNotesStructuredFields.cs b/Data.SeaHavenIndustries/Migrations/20260715160000_WoServiceNotesStructuredFields.cs
new file mode 100644
index 0000000..e49532f
--- /dev/null
+++ b/Data.SeaHavenIndustries/Migrations/20260715160000_WoServiceNotesStructuredFields.cs
@@ -0,0 +1,121 @@
+using Data.SeaHavenIndustries;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Data.SeaHavenIndustries.Migrations
+{
+    /// <inheritdoc />
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20260715160000_WoServiceNotesStructuredFields")]
+    public partial class WoServiceNotesStructuredFields : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "PocName",
+                table: "workOrders",
+                type: "nvarchar(200)",
+                maxLength: 200,
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "PocPhone",
+                table: "workOrders",
+                type: "nvarchar(50)",
+                maxLength: 50,
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "PocNotes",
+                table: "workOrders",
+                type: "nvarchar(2000)",
+                maxLength: 2000,
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "ExtraServices",
+                table: "workOrders",
+                type: "nvarchar(2000)",
+                maxLength: 2000,
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "ServiceNotes",
+                table: "workOrders",
+                type: "nvarchar(4000)",
+                maxLength: 4000,
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "TechPhone",
+                table: "workOrders",
+                type: "nvarchar(50)",
+                maxLength: 50,
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "VendorNotes",
+                table: "workOrders",
+                type: "nvarchar(2000)",
+                maxLength: 2000,
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "TechPhone",
+                table: "Dispatches",
+                type: "nvarchar(50)",
+                maxLength: 50,
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "VendorNotes",
+                table: "Dispatches",
+                type: "nvarchar(2000)",
+                maxLength: 2000,
+                nullable: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "PocName",
+                table: "workOrders");
+
+            migrationBuilder.DropColumn(
+                name: "PocPhone",
+                table: "workOrders");
+
+            migrationBuilder.DropColumn(
+                name: "PocNotes",
+                table: "workOrders");
+
+            migrationBuilder.DropColumn(
+                name: "ExtraServices",
+                table: "workOrders");
+
+            migrationBuilder.DropColumn(
+                name: "ServiceNotes",
+                table: "workOrders");
+
+            migrationBuilder.DropColumn(
+                name: "TechPhone",
+                table: "workOrders");
+
+            migrationBuilder.DropColumn(
+                name: "VendorNotes",
+                table: "workOrders");
+
+            migrationBuilder.DropColumn(
+                name: "TechPhone",
+                table: "Dispatches");
+
+            migrationBuilder.DropColumn(
+                name: "VendorNotes",
+                table: "Dispatches");
+        }
+    }
+}
diff --git a/Data.SeaHavenIndustries/Migrations/20260715180000_WoFlagColor.cs b/Data.SeaHavenIndustries/Migrations/20260715180000_WoFlagColor.cs
new file mode 100644
index 0000000..e48600e
--- /dev/null
+++ b/Data.SeaHavenIndustries/Migrations/20260715180000_WoFlagColor.cs
@@ -0,0 +1,33 @@
+using Data.SeaHavenIndustries;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Data.SeaHavenIndustries.Migrations
+{
+    /// <inheritdoc />
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20260715180000_WoFlagColor")]
+    public partial class WoFlagColor : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "FlagColor",
+                table: "workOrders",
+                type: "nvarchar(7)",
+                maxLength: 7,
+                nullable: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "FlagColor",
+                table: "workOrders");
+        }
+    }
+}
diff --git a/Data.SeaHavenIndustries/Migrations/20260717140000_AddEventsCalendarTable.cs b/Data.SeaHavenIndustries/Migrations/20260717140000_AddEventsCalendarTable.cs
new file mode 100644
index 0000000..6dcb796
--- /dev/null
+++ b/Data.SeaHavenIndustries/Migrations/20260717140000_AddEventsCalendarTable.cs
@@ -0,0 +1,58 @@
+using Data.SeaHavenIndustries;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Data.SeaHavenIndustries.Migrations
+{
+    /// <inheritdoc />
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20260717140000_AddEventsCalendarTable")]
+    public partial class AddEventsCalendarTable : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            // Events entity existed in the model/DbSet without a discoverable migration.
+            migrationBuilder.Sql(@"
+                IF OBJECT_ID(N'dbo.Events', N'U') IS NULL
+                BEGIN
+                    CREATE TABLE Events (
+                        Id int NOT NULL IDENTITY(1,1),
+                        Title nvarchar(100) NOT NULL,
+                        Description nvarchar(max) NULL,
+                        Location nvarchar(150) NULL,
+                        RecordID int NULL,
+                        RecordName nvarchar(max) NULL,
+                        RecordTargetType nvarchar(max) NULL,
+                        ReminderMinutes int NOT NULL,
+                        EventColor nvarchar(20) NOT NULL,
+                        StartDate datetime2 NOT NULL,
+                        StartTime nvarchar(10) NULL,
+                        EndDate datetime2 NOT NULL,
+                        EndTime nvarchar(10) NULL,
+                        AllDay 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,
+                        CONSTRAINT PK_Events PRIMARY KEY (Id)
+                    );
+                END
+            ");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.Sql(@"
+                IF OBJECT_ID(N'dbo.Events', N'U') IS NOT NULL
+                    DROP TABLE Events;
+            ");
+        }
+    }
+}
diff --git a/Data.SeaHavenIndustries/Migrations/ApplicationDbContextModelSnapshot.cs b/Data.SeaHavenIndustries/Migrations/ApplicationDbContextModelSnapshot.cs
index 7479f75..4ff0be1 100644
--- a/Data.SeaHavenIndustries/Migrations/ApplicationDbContextModelSnapshot.cs
+++ b/Data.SeaHavenIndustries/Migrations/ApplicationDbContextModelSnapshot.cs
@@ -186,6 +186,9 @@ namespace Data.SeaHavenIndustries.Migrations
                     b.Property<int>("AccessFailedCount")
                         .HasColumnType("int");
 
+                    b.Property<string>("Color")
+                        .HasColumnType("nvarchar(max)");
+
                     b.Property<string>("ConcurrencyStamp")
                         .IsConcurrencyToken()
                         .HasColumnType("nvarchar(max)");
@@ -209,6 +212,9 @@ namespace Data.SeaHavenIndustries.Migrations
                     b.Property<string>("FirstName")
                         .HasColumnType("nvarchar(max)");
 
+                    b.Property<string>("Initials")
+                        .HasColumnType("nvarchar(max)");
+
                     b.Property<bool?>("IsDeleted")
                         .HasColumnType("bit");
 
@@ -435,6 +441,60 @@ namespace Data.SeaHavenIndustries.Migrations
                     b.ToTable("Comments");
                 });
 
+            modelBuilder.Entity("Data.SeaHavenIndustries.CompletionDocTemplate", 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>("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()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ServiceKey")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("TemplateUrl")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("WorkOrderType")
+                        .HasColumnType("int");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ServiceKey", "IsActive");
+
+                    b.ToTable("CompletionDocTemplates");
+                });
+
             modelBuilder.Entity("Data.SeaHavenIndustries.ContactDetails", b =>
                 {
                     b.Property<int>("Id")
@@ -601,32 +661,11 @@ namespace Data.SeaHavenIndustries.Migrations
 
                     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<string>("Name")
                         .IsRequired()
                         .HasMaxLength(200)
                         .HasColumnType("nvarchar(200)");
 
-                    b.Property<string>("createdby")
-                        .HasColumnType("nvarchar(max)");
-
                     b.HasKey("Id");
 
                     b.ToTable("Departments");
@@ -688,15 +727,28 @@ namespace Data.SeaHavenIndustries.Migrations
                     b.Property<string>("ReplyToAddress")
                         .HasColumnType("nvarchar(max)");
 
+                    b.Property<byte[]>("RowVersion")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("rowversion");
+
                     b.Property<DateTime?>("ScheduledDate")
                         .HasColumnType("datetime2");
 
                     b.Property<string>("Status")
                         .HasColumnType("nvarchar(max)");
 
+                    b.Property<string>("TechPhone")
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
                     b.Property<int>("VendorId")
                         .HasColumnType("int");
 
+                    b.Property<string>("VendorNotes")
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
                     b.Property<DateTime?>("VerifiedAt")
                         .HasColumnType("datetime2");
 
@@ -1111,36 +1163,15 @@ namespace Data.SeaHavenIndustries.Migrations
                         .HasMaxLength(256)
                         .HasColumnType("nvarchar(256)");
 
-                    b.Property<DateTime?>("CreatedDate")
-                        .HasColumnType("datetime2");
-
-                    b.Property<string>("DeleterUserId")
-                        .HasColumnType("nvarchar(max)");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("datetime2");
-
                     b.Property<int?>("EmailTypeId")
                         .HasColumnType("int");
 
                     b.Property<int>("EmployeeId")
                         .HasColumnType("int");
 
-                    b.Property<bool?>("IsDeleted")
-                        .HasColumnType("bit");
-
                     b.Property<bool?>("IsPrimary")
                         .HasColumnType("bit");
 
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("datetime2");
-
-                    b.Property<int?>("LastModifierUserId")
-                        .HasColumnType("int");
-
-                    b.Property<string>("createdby")
-                        .HasColumnType("nvarchar(max)");
-
                     b.HasKey("Id");
 
                     b.HasIndex("EmployeeId");
@@ -1178,6 +1209,86 @@ namespace Data.SeaHavenIndustries.Migrations
                     b.ToTable("EmployeePhones");
                 });
 
+            modelBuilder.Entity("Data.SeaHavenIndustries.Events", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<bool>("AllDay")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("CreatedDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("DeleterUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("EndDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("EndTime")
+                        .HasMaxLength(10)
+                        .HasColumnType("nvarchar(10)");
+
+                    b.Property<string>("EventColor")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("nvarchar(20)");
+
+                    b.Property<bool?>("IsDeleted")
+                        .HasColumnType("bit");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("LastModifierUserId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Location")
+                        .HasMaxLength(150)
+                        .HasColumnType("nvarchar(150)");
+
+                    b.Property<int?>("RecordID")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RecordName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("RecordTargetType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("ReminderMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("StartDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("StartTime")
+                        .HasMaxLength(10)
+                        .HasColumnType("nvarchar(10)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("createdby")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Events");
+                });
+
             modelBuilder.Entity("Data.SeaHavenIndustries.FollowUps", b =>
                 {
                     b.Property<int>("Id")
@@ -1279,32 +1390,11 @@ namespace Data.SeaHavenIndustries.Migrations
 
                     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<string>("Name")
                         .IsRequired()
                         .HasMaxLength(200)
                         .HasColumnType("nvarchar(200)");
 
-                    b.Property<string>("createdby")
-                        .HasColumnType("nvarchar(max)");
-
                     b.HasKey("Id");
 
                     b.ToTable("JobTitles");
@@ -1318,21 +1408,15 @@ namespace Data.SeaHavenIndustries.Migrations
 
                     SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
 
-                    b.Property<int?>("AccountId")
-                        .HasColumnType("int");
+                    b.Property<string>("Address1")
+                        .HasColumnType("nvarchar(max)");
 
-                    b.Property<string>("Address")
+                    b.Property<string>("Address2")
                         .HasColumnType("nvarchar(max)");
 
                     b.Property<string>("City")
                         .HasColumnType("nvarchar(max)");
 
-                    b.Property<string>("Contact")
-                        .HasColumnType("nvarchar(max)");
-
-                    b.Property<string>("ContactEmail")
-                        .HasColumnType("nvarchar(max)");
-
                     b.Property<DateTime?>("CreatedDate")
                         .HasColumnType("datetime2");
 
@@ -1342,6 +1426,9 @@ namespace Data.SeaHavenIndustries.Migrations
                     b.Property<DateTime?>("DeletionTime")
                         .HasColumnType("datetime2");
 
+                    b.Property<string>("Email")
+                        .HasColumnType("nvarchar(max)");
+
                     b.Property<bool?>("IsDeleted")
                         .HasColumnType("bit");
 
@@ -1360,7 +1447,7 @@ namespace Data.SeaHavenIndustries.Migrations
                     b.Property<string>("Name")
                         .HasColumnType("nvarchar(max)");
 
-                    b.Property<string>("Phone")
+                    b.Property<string>("PhoneNumber")
                         .HasColumnType("nvarchar(max)");
 
                     b.Property<string>("State")
@@ -1372,7 +1459,7 @@ namespace Data.SeaHavenIndustries.Migrations
                     b.Property<string>("Title")
                         .HasColumnType("nvarchar(max)");
 
-                    b.Property<string>("ZipCode")
+                    b.Property<string>("Zip")
                         .HasColumnType("nvarchar(max)");
 
                     b.Property<string>("createdby")
@@ -1380,8 +1467,6 @@ namespace Data.SeaHavenIndustries.Migrations
 
                     b.HasKey("Id");
 
-                    b.HasIndex("AccountId");
-
                     b.ToTable("Locations");
                 });
 
@@ -1573,32 +1658,11 @@ namespace Data.SeaHavenIndustries.Migrations
 
                     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<string>("Name")
                         .IsRequired()
                         .HasMaxLength(200)
                         .HasColumnType("nvarchar(200)");
 
-                    b.Property<string>("createdby")
-                        .HasColumnType("nvarchar(max)");
-
                     b.HasKey("Id");
 
                     b.ToTable("Regions");
@@ -1931,12 +1995,18 @@ namespace Data.SeaHavenIndustries.Migrations
                     b.Property<string>("AfterPhotoIssue")
                         .HasColumnType("nvarchar(max)");
 
+                    b.Property<DateOnly?>("AssignDate")
+                        .HasColumnType("date");
+
                     b.Property<string>("AssignTo")
                         .HasColumnType("nvarchar(450)");
 
                     b.Property<string>("Attachments")
                         .HasColumnType("nvarchar(max)");
 
+                    b.Property<string>("AvettaTask")
+                        .HasColumnType("nvarchar(max)");
+
                     b.Property<string>("BeforPhotoAttachment")
                         .HasColumnType("nvarchar(max)");
 
@@ -1946,6 +2016,9 @@ namespace Data.SeaHavenIndustries.Migrations
                     b.Property<string>("Building")
                         .HasColumnType("nvarchar(max)");
 
+                    b.Property<int>("CarriedOver")
+                        .HasColumnType("int");
+
                     b.Property<DateTime?>("CompletedDate")
                         .HasColumnType("datetime2");
 
@@ -1967,14 +2040,27 @@ namespace Data.SeaHavenIndustries.Migrations
                     b.Property<string>("Description")
                         .HasColumnType("nvarchar(max)");
 
+                    b.Property<int?>("DocStatus")
+                        .HasColumnType("int");
+
                     b.Property<DateTime?>("DueDate")
                         .HasColumnType("datetime2");
 
                     b.Property<string>("ExternalWorkOrderId")
-                        .HasColumnType("nvarchar(max)");
+                        .HasMaxLength(450)
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ExtraServices")
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
+                    b.Property<string>("FlagColor")
+                        .HasMaxLength(7)
+                        .HasColumnType("nvarchar(7)");
 
                     b.Property<string>("InternalWONumber")
-                        .HasColumnType("nvarchar(max)");
+                        .HasMaxLength(450)
+                        .HasColumnType("nvarchar(450)");
 
                     b.Property<bool?>("IsDeleted")
                         .HasColumnType("bit");
@@ -1985,24 +2071,76 @@ namespace Data.SeaHavenIndustries.Migrations
                     b.Property<int?>("LastModifierUserId")
                         .HasColumnType("int");
 
+                    b.Property<string>("LegacyStatus")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("LifecycleStatus")
+                        .HasColumnType("int");
+
                     b.Property<int?>("LocationId")
                         .HasColumnType("int");
 
+                    b.Property<int>("OperationalFlags")
+                        .HasColumnType("int");
+
+                    b.Property<DateOnly?>("OriginalDate")
+                        .HasColumnType("date");
+
+                    b.Property<DateOnly?>("OriginalWeek")
+                        .HasColumnType("date");
+
                     b.Property<string>("PO")
                         .HasColumnType("nvarchar(max)");
 
+                    b.Property<string>("PocName")
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("PocNotes")
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
+                    b.Property<string>("PocPhone")
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<int?>("PrimaryDispatchId")
+                        .HasColumnType("int");
+
                     b.Property<string>("Priority")
                         .HasColumnType("nvarchar(max)");
 
                     b.Property<string>("Problem")
                         .HasColumnType("nvarchar(max)");
 
+                    b.Property<int>("RescheduleCount")
+                        .HasColumnType("int");
+
+                    b.Property<byte[]>("RowVersion")
+                        .IsConcurrencyToken()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("rowversion");
+
+                    b.Property<bool?>("ScheduleWeekOnly")
+                        .HasColumnType("bit");
+
                     b.Property<DateTime?>("ScheduledDate")
                         .HasColumnType("datetime2");
 
+                    b.Property<DateTime?>("ScheduledEnd")
+                        .HasColumnType("datetime2");
+
                     b.Property<DateTime?>("ScheduledStart")
                         .HasColumnType("datetime2");
 
+                    b.Property<string>("Service")
+                        .HasMaxLength(128)
+                        .HasColumnType("nvarchar(128)");
+
+                    b.Property<string>("ServiceNotes")
+                        .HasMaxLength(4000)
+                        .HasColumnType("nvarchar(4000)");
+
                     b.Property<string>("Severity")
                         .HasColumnType("nvarchar(max)");
 
@@ -2016,7 +2154,8 @@ namespace Data.SeaHavenIndustries.Migrations
                         .HasColumnType("nvarchar(max)");
 
                     b.Property<string>("SiteCode")
-                        .HasColumnType("nvarchar(max)");
+                        .HasMaxLength(450)
+                        .HasColumnType("nvarchar(450)");
 
                     b.Property<string>("Source")
                         .HasColumnType("nvarchar(max)");
@@ -2033,12 +2172,26 @@ namespace Data.SeaHavenIndustries.Migrations
                     b.Property<string>("TT")
                         .HasColumnType("nvarchar(max)");
 
+                    b.Property<DateOnly?>("TargetWeek")
+                        .HasColumnType("date");
+
+                    b.Property<string>("TechPhone")
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
                     b.Property<string>("Trade")
                         .HasColumnType("nvarchar(max)");
 
                     b.Property<decimal?>("VendorNTE")
                         .HasColumnType("decimal(18,2)");
 
+                    b.Property<string>("VendorNotes")
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
+                    b.Property<int?>("WorkOrderType")
+                        .HasColumnType("int");
+
                     b.Property<string>("WorkerOrderNumber")
                         .HasColumnType("nvarchar(max)");
 
@@ -2055,8 +2208,29 @@ namespace Data.SeaHavenIndustries.Migrations
 
                     b.HasIndex("AssignTo");
 
+                    b.HasIndex("ExternalWorkOrderId")
+                        .IsUnique()
+                        .HasFilter("[ExternalWorkOrderId] IS NOT NULL AND [ExternalWorkOrderId] <> ''");
+
+                    b.HasIndex("InternalWONumber")
+                        .HasFilter("[istemplate] = 0");
+
                     b.HasIndex("LocationId");
 
+                    b.HasIndex("PrimaryDispatchId");
+
+                    b.HasIndex("ScheduledDate");
+
+                    b.HasIndex("SiteCode")
+                        .HasFilter("[istemplate] = 0");
+
+                    b.HasIndex("WorkOrderType");
+
+                    b.HasIndex("AssignTo", "ScheduledDate");
+
+                    b.HasIndex("LifecycleStatus", "ScheduledDate")
+                        .HasFilter("[istemplate] = 0");
+
                     b.ToTable("workOrders");
                 });
 
@@ -2071,6 +2245,9 @@ namespace Data.SeaHavenIndustries.Migrations
                     b.Property<string>("Attachments")
                         .HasColumnType("nvarchar(max)");
 
+                    b.Property<int?>("Category")
+                        .HasColumnType("int");
+
                     b.Property<DateTime?>("CreatedDate")
                         .HasColumnType("datetime2");
 
@@ -2113,9 +2290,21 @@ namespace Data.SeaHavenIndustries.Migrations
                     b.Property<string>("Action")
                         .HasColumnType("nvarchar(max)");
 
+                    b.Property<string>("ActorType")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("CorrelationId")
+                        .HasColumnType("nvarchar(max)");
+
                     b.Property<DateTime>("CreatedAt")
                         .HasColumnType("datetime2");
 
+                    b.Property<int?>("DispatchId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EventType")
+                        .HasColumnType("nvarchar(max)");
+
                     b.Property<string>("FieldName")
                         .HasColumnType("nvarchar(max)");
 
@@ -2213,6 +2402,9 @@ namespace Data.SeaHavenIndustries.Migrations
                     b.Property<int?>("LastModifierUserId")
                         .HasColumnType("int");
 
+                    b.Property<string>("Notes")
+                        .HasColumnType("nvarchar(max)");
+
                     b.Property<int?>("WorkorderId")
                         .HasColumnType("int");
 
@@ -2228,6 +2420,64 @@ namespace Data.SeaHavenIndustries.Migrations
                     b.ToTable("WorkOrderContacts");
                 });
 
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderFieldLock", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("FieldName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<DateTime>("LockedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LockedByUserId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorkOrderId", "FieldName")
+                        .IsUnique();
+
+                    b.ToTable("WorkOrderFieldLocks");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderWeekRolledLedger", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("CorrelationId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("ProcessedAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateOnly>("SourceWeekStart")
+                        .HasColumnType("date");
+
+                    b.Property<int>("WorkOrderId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorkOrderId", "SourceWeekStart")
+                        .IsUnique();
+
+                    b.ToTable("WorkOrderWeekRolledLedgers");
+                });
+
             modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
                 {
                     b.Property<string>("Id")
@@ -2457,8 +2707,7 @@ namespace Data.SeaHavenIndustries.Migrations
 
                     b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
                         .WithMany("Dispatches")
-                        .HasForeignKey("WorkOrderId")
-                        .OnDelete(DeleteBehavior.Restrict);
+                        .HasForeignKey("WorkOrderId");
 
                     b.Navigation("Vendor");
 
@@ -2612,16 +2861,6 @@ namespace Data.SeaHavenIndustries.Migrations
                     b.Navigation("WorkOrder");
                 });
 
-            modelBuilder.Entity("Data.SeaHavenIndustries.Locations", b =>
-                {
-                    b.HasOne("Data.SeaHavenIndustries.Accounts", "Account")
-                        .WithMany()
-                        .HasForeignKey("AccountId")
-                        .OnDelete(DeleteBehavior.Restrict);
-
-                    b.Navigation("Account");
-                });
-
             modelBuilder.Entity("Data.SeaHavenIndustries.PMSchedules", b =>
                 {
                     b.HasOne("Data.SeaHavenIndustries.Assets", "Asset")
@@ -2731,9 +2970,16 @@ namespace Data.SeaHavenIndustries.Migrations
                         .HasForeignKey("LocationId")
                         .OnDelete(DeleteBehavior.Restrict);
 
+                    b.HasOne("Data.SeaHavenIndustries.Dispatch", "PrimaryDispatch")
+                        .WithMany()
+                        .HasForeignKey("PrimaryDispatchId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
                     b.Navigation("AssignToUser");
 
                     b.Navigation("Locations");
+
+                    b.Navigation("PrimaryDispatch");
                 });
 
             modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderAttachments", b =>
@@ -2798,6 +3044,28 @@ namespace Data.SeaHavenIndustries.Migrations
                     b.Navigation("WorkOrder");
                 });
 
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderFieldLock", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany("FieldLocks")
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("WorkOrder");
+                });
+
+            modelBuilder.Entity("Data.SeaHavenIndustries.WorkOrderWeekRolledLedger", b =>
+                {
+                    b.HasOne("Data.SeaHavenIndustries.WorkOrder", "WorkOrder")
+                        .WithMany()
+                        .HasForeignKey("WorkOrderId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("WorkOrder");
+                });
+
             modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
                 {
                     b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
@@ -2943,6 +3211,8 @@ namespace Data.SeaHavenIndustries.Migrations
 
                     b.Navigation("Dispatches");
 
+                    b.Navigation("FieldLocks");
+
                     b.Navigation("Quotes");
 
                     b.Navigation("WorkOrderCategories");
diff --git a/Data.SeaHavenIndustries/Models/CompletionDocTemplate.cs b/Data.SeaHavenIndustries/Models/CompletionDocTemplate.cs
new file mode 100644
index 0000000..17cb4d3
--- /dev/null
+++ b/Data.SeaHavenIndustries/Models/CompletionDocTemplate.cs
@@ -0,0 +1,13 @@
+using Data.SeaHavenIndustries.Enums;
+
+namespace Data.SeaHavenIndustries
+{
+    public class CompletionDocTemplate : FullAuditEntity
+    {
+        public string Name { get; set; } = "";
+        public string ServiceKey { get; set; } = "";
+        public WorkOrderType? WorkOrderType { get; set; }
+        public string TemplateUrl { get; set; } = "";
+        public bool IsActive { get; set; } = true;
+    }
+}
diff --git a/Data.SeaHavenIndustries/Models/Dispatch.cs b/Data.SeaHavenIndustries/Models/Dispatch.cs
index 869fedf..7fe14f3 100644
--- a/Data.SeaHavenIndustries/Models/Dispatch.cs
+++ b/Data.SeaHavenIndustries/Models/Dispatch.cs
@@ -1,3 +1,4 @@
+using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
 
 namespace Data.SeaHavenIndustries
@@ -26,6 +27,17 @@ namespace Data.SeaHavenIndustries
         public string? AcceptToken { get; set; }
         public string? VerifiedBy { get; set; }
         public DateTime? VerifiedAt { get; set; }
+
+        /// <summary>Tech/crew phone for this dispatch (overrides Vendor.Phone on board).</summary>
+        [MaxLength(50)]
+        public string? TechPhone { get; set; }
+        /// <summary>Instructions for the vendor for this appointment/dispatch.</summary>
+        [MaxLength(2000)]
+        public string? VendorNotes { get; set; }
+
+        [Timestamp]
+        public byte[]? RowVersion { get; set; }
+
         public ICollection<Comments>? Comments { get; set; }
         public ICollection<DispatchWorkOrder>? DispatchWorkOrders { get; set; }
         public ICollection<DispatchChecklistItem>? ChecklistItems { get; set; }
diff --git a/Data.SeaHavenIndustries/Models/WorkOrderAttachments.cs b/Data.SeaHavenIndustries/Models/WorkOrderAttachments.cs
index ff8672b..fbeee87 100644
--- a/Data.SeaHavenIndustries/Models/WorkOrderAttachments.cs
+++ b/Data.SeaHavenIndustries/Models/WorkOrderAttachments.cs
@@ -1,15 +1,14 @@
-using System;
-using System.ComponentModel.DataAnnotations.Schema;
-using static System.Runtime.InteropServices.JavaScript.JSType;
+using System.ComponentModel.DataAnnotations.Schema;
+using Data.SeaHavenIndustries.Enums;
 
 namespace Data.SeaHavenIndustries
 {
     public class WorkOrderAttachments : FullAuditEntity
     {
         public string? Attachments { get; set; }
+        public WorkOrderMediaCategory? Category { get; set; }
         public int? WorkorderId { get; set; }
         [ForeignKey(nameof(WorkorderId))]
         public virtual WorkOrder? WorkOrder { get; set; }
-
     }
 }
diff --git a/Data.SeaHavenIndustries/Models/WorkOrderAuditLog.cs b/Data.SeaHavenIndustries/Models/WorkOrderAuditLog.cs
index 0b2572f..b3fbb7d 100644
--- a/Data.SeaHavenIndustries/Models/WorkOrderAuditLog.cs
+++ b/Data.SeaHavenIndustries/Models/WorkOrderAuditLog.cs
@@ -15,6 +15,10 @@ namespace Data.SeaHavenIndustries
         public string? OldValue { get; set; }
         public string? NewValue { get; set; }
         public string? Action { get; set; }
+        public string? EventType { get; set; }
+        public string? ActorType { get; set; }
+        public int? DispatchId { get; set; }
+        public string? CorrelationId { get; set; }
         public DateTime CreatedAt { get; set; }
     }
 }
diff --git a/Data.SeaHavenIndustries/Models/WorkOrderContacts.cs b/Data.SeaHavenIndustries/Models/WorkOrderContacts.cs
index 96e89eb..52919ea 100644
--- a/Data.SeaHavenIndustries/Models/WorkOrderContacts.cs
+++ b/Data.SeaHavenIndustries/Models/WorkOrderContacts.cs
@@ -12,6 +12,6 @@ namespace Data.SeaHavenIndustries
         public int? WorkorderId { get; set; }
         [ForeignKey(nameof(WorkorderId))]
         public virtual WorkOrder? WorkOrder { get; set; }
-
+        public string? Notes { get; set; }
     }
 }
diff --git a/Data.SeaHavenIndustries/Models/WorkOrderFieldLock.cs b/Data.SeaHavenIndustries/Models/WorkOrderFieldLock.cs
new file mode 100644
index 0000000..c749159
--- /dev/null
+++ b/Data.SeaHavenIndustries/Models/WorkOrderFieldLock.cs
@@ -0,0 +1,18 @@
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace Data.SeaHavenIndustries
+{
+    /// <summary>
+    /// ManualEditFlag — blocks Sync overwrite after first SHOC edit per field.
+    /// </summary>
+    public class WorkOrderFieldLock
+    {
+        public int Id { get; set; }
+        public int WorkOrderId { get; set; }
+        [ForeignKey(nameof(WorkOrderId))]
+        public virtual WorkOrder? WorkOrder { get; set; }
+        public string FieldName { get; set; } = "";
+        public DateTime LockedAt { get; set; }
+        public string? LockedByUserId { get; set; }
+    }
+}
diff --git a/Data.SeaHavenIndustries/Models/WorkOrderWeekRolledLedger.cs b/Data.SeaHavenIndustries/Models/WorkOrderWeekRolledLedger.cs
new file mode 100644
index 0000000..efa661a
--- /dev/null
+++ b/Data.SeaHavenIndustries/Models/WorkOrderWeekRolledLedger.cs
@@ -0,0 +1,15 @@
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace Data.SeaHavenIndustries
+{
+    public class WorkOrderWeekRolledLedger
+    {
+        public int Id { get; set; }
+        public int WorkOrderId { get; set; }
+        [ForeignKey(nameof(WorkOrderId))]
+        public virtual WorkOrder? WorkOrder { get; set; }
+        public DateOnly SourceWeekStart { get; set; }
+        public DateTime ProcessedAt { get; set; }
+        public string CorrelationId { get; set; } = "";
+    }
+}
diff --git a/Data.SeaHavenIndustries/Models/WorkerOrder.cs b/Data.SeaHavenIndustries/Models/WorkerOrder.cs
index 6d3692e..15b5222 100644
--- a/Data.SeaHavenIndustries/Models/WorkerOrder.cs
+++ b/Data.SeaHavenIndustries/Models/WorkerOrder.cs
@@ -1,48 +1,101 @@
-using System;
+using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
-using static System.Runtime.InteropServices.JavaScript.JSType;
+using Data.SeaHavenIndustries.Enums;
 
 namespace Data.SeaHavenIndustries
 {
     public class WorkOrder : FullAuditEntity
     {
+        // --- Core slice ---
+        [MaxLength(450)]
         public string? InternalWONumber { get; set; }
+        [MaxLength(450)]
         public string? ExternalWorkOrderId { get; set; }
         public string? WorkerOrderNumber { get; set; }
         public string? WorkerOrderTitle { get; set; }
         public string? Description { get; set; }
         public string? Customer { get; set; }
+        [MaxLength(450)]
         public string? SiteCode { get; set; }
         public string? Building { get; set; }
         public string? Severity { get; set; }
-        public DateTime? DateReported { get; set; }
+        public DateTime? DueDate { get; set; }
+        public string? AssignTo { get; set; }
+        [ForeignKey(nameof(AssignTo))]
+        public virtual ApplicationUser? AssignToUser { get; set; }
+        public int? LocationId { get; set; }
+        [ForeignKey(nameof(LocationId))]
+        public virtual Locations? Locations { get; set; }
+        public LifecycleStatus? LifecycleStatus { get; set; }
+        public string? LegacyStatus { get; set; }
+        public WorkOrderType? WorkOrderType { get; set; }
+        /// <summary>SHOC board "Service" column (PM type label). Not Trade/Problem.</summary>
+        [MaxLength(128)]
+        public string? Service { get; set; }
+        public int? PrimaryDispatchId { get; set; }
+        [ForeignKey(nameof(PrimaryDispatchId))]
+        public virtual Dispatch? PrimaryDispatch { get; set; }
+
+        // --- Service & Notes / POC (structured create) ---
+        [MaxLength(200)]
+        public string? PocName { get; set; }
+        [MaxLength(50)]
+        public string? PocPhone { get; set; }
+        [MaxLength(2000)]
+        public string? PocNotes { get; set; }
+        /// <summary>JSON array of extra service labels beyond primary (Trade).</summary>
+        [MaxLength(2000)]
+        public string? ExtraServices { get; set; }
+        [MaxLength(4000)]
+        public string? ServiceNotes { get; set; }
+        /// <summary>Tech/crew phone when no primary dispatch; otherwise prefer Dispatch.TechPhone.</summary>
+        [MaxLength(50)]
+        public string? TechPhone { get; set; }
+        /// <summary>Vendor instructions when no primary dispatch; otherwise prefer Dispatch.VendorNotes.</summary>
+        [MaxLength(2000)]
+        public string? VendorNotes { get; set; }
+
+        // --- Scheduling slice ---
+        public DateTime? ScheduledDate { get; set; }
         public DateTime? ScheduledStart { get; set; }
+        public DateTime? ScheduledEnd { get; set; }
+        public DateOnly? TargetWeek { get; set; }
+        public bool? ScheduleWeekOnly { get; set; }
+
+        // --- Tracking slice (set-once) ---
+        public DateOnly? OriginalWeek { get; set; }
+        public DateOnly? OriginalDate { get; set; }
+
+        // --- Analytics slice ---
+        public int RescheduleCount { get; set; }
+        public int CarriedOver { get; set; }
+        public OperationalFlags OperationalFlags { get; set; }
+
+        // --- Completion slice ---
+        public DocStatus? DocStatus { get; set; }
+
+        /// <summary>Board flag color (#RRGGBB from fixed palette). Null = no flag.</summary>
+        [MaxLength(7)]
+        public string? FlagColor { get; set; }
+
+        // --- Legacy SQL columns (drift reconciliation) ---
+        public string? AvettaTask { get; set; }
+        public DateOnly? AssignDate { get; set; }
+
+        // --- Legacy fields (retained for Blazor / coexistence) ---
+        public DateTime? DateReported { get; set; }
         public string? SourceEmailS3Key { get; set; }
         public string? Problem { get; set; }
         public string? Trade { get; set; }
         public string? SubTrade { get; set; }
         public decimal? VendorNTE { get; set; }
-        public DateTime? ScheduledDate { get; set; }
         public DateTime? CompletedDate { get; set; }
         public string? Source { get; set; }
         public bool? istemplate { get; set; }
         public string? PO { get; set; }
         public string? TT { get; set; }
-        //public int? ContactId { get; set; }
-        //[ForeignKey(nameof(ContactId))]
-        //public virtual Contacts? POC { get; set; }
-        public string? AssignTo { get; set; }
-        [ForeignKey(nameof(AssignTo))]
-        public virtual ApplicationUser? AssignToUser { get; set; }
-        public DateTime? DueDate { get; set; }
         public string? Priority { get; set; }
         public string? Status { get; set; }
-        public int? LocationId { get; set; }
-        [ForeignKey(nameof(LocationId))]
-        public virtual Locations? Locations { get; set; }
-        //public int? CategoryId { get; set; }
-        //[ForeignKey(nameof(CategoryId))]
-        //public virtual Category? Category { get; set; }
         public string? Attachments { get; set; }
         public string? BeforPhotoIssue { get; set; }
         public string? BeforPhotoAttachment { get; set; }
@@ -51,11 +104,16 @@ namespace Data.SeaHavenIndustries
         public string? SignOffName { get; set; }
         public string? SignOffAttachment { get; set; }
         public string? SignOffSignature { get; set; }
+
+        [Timestamp]
+        public byte[]? RowVersion { get; set; }
+
         public ICollection<Comments>? Comments { get; set; }
         public ICollection<Quotes>? Quotes { get; set; }
         public ICollection<WorkOrderContacts>? WorkOrderContacts { get; set; }
         public ICollection<WorkOrderAttachments>? workOrderAttachments { get; set; }
         public ICollection<WorkOrderCategories>? WorkOrderCategories { get; set; }
         public ICollection<Dispatch>? Dispatches { get; set; }
+        public ICollection<WorkOrderFieldLock>? FieldLocks { get; set; }
     }
 }
diff --git a/SeaHaven.DataServices/Board/WorkOrderBoardConstants.cs b/SeaHaven.DataServices/Board/WorkOrderBoardConstants.cs
new file mode 100644
index 0000000..bceff32
--- /dev/null
+++ b/SeaHaven.DataServices/Board/WorkOrderBoardConstants.cs
@@ -0,0 +1,7 @@
+namespace SeaHaven.DataServices.Board
+{
+    public static class WorkOrderBoardConstants
+    {
+        public const int ClientSideThreshold = 300;
+    }
+}
diff --git a/SeaHaven.DataServices/DTOs/WorkOrderBoardQuery.cs b/SeaHaven.DataServices/DTOs/WorkOrderBoardQuery.cs
new file mode 100644
index 0000000..6d5d1e0
--- /dev/null
+++ b/SeaHaven.DataServices/DTOs/WorkOrderBoardQuery.cs
@@ -0,0 +1,10 @@
+namespace SeaHaven.DataServices.DTOs
+{
+    public record WorkOrderBoardQuery(
+        DateOnly ScheduledFrom,
+        DateOnly ScheduledTo,
+        string? Search,
+        IReadOnlyList<string>? AssigneeIds,
+        IReadOnlyList<string>? DbStatuses,
+        int? LocationId);
+}
diff --git a/SeaHaven.DataServices/DTOs/WorkOrderBoardRowData.cs b/SeaHaven.DataServices/DTOs/WorkOrderBoardRowData.cs
new file mode 100644
index 0000000..a7eca60
--- /dev/null
+++ b/SeaHaven.DataServices/DTOs/WorkOrderBoardRowData.cs
@@ -0,0 +1,20 @@
+namespace SeaHaven.DataServices.DTOs
+{
+    public record WorkOrderBoardRowData(
+        int Id,
+        string? WoNumber,
+        string? SiteCode,
+        string? LocationLabel,
+        DateTime? ScheduledDate,
+        DateTime? ScheduledStart,
+        DateTime? DueDate,
+        string? WorkOrderType,
+        string? ServiceType,
+        string? AssigneeId,
+        string? AssigneeName,
+        string? VendorCompany,
+        string? VendorTechnician,
+        string? Status,
+        string? PocName,
+        string? PocPhone);
+}
diff --git a/SeaHaven.DataServices/Exceptions/BoardQueryException.cs b/SeaHaven.DataServices/Exceptions/BoardQueryException.cs
new file mode 100644
index 0000000..b659424
--- /dev/null
+++ b/SeaHaven.DataServices/Exceptions/BoardQueryException.cs
@@ -0,0 +1,9 @@
+namespace SeaHaven.DataServices.Exceptions
+{
+    public class BoardQueryException : Exception
+    {
+        public BoardQueryException(string message) : base(message)
+        {
+        }
+    }
+}
diff --git a/SeaHaven.DataServices/Helpers/WorkOrderBoardProjection.cs b/SeaHaven.DataServices/Helpers/WorkOrderBoardProjection.cs
new file mode 100644
index 0000000..5520791
--- /dev/null
+++ b/SeaHaven.DataServices/Helpers/WorkOrderBoardProjection.cs
@@ -0,0 +1,127 @@
+using Data.SeaHavenIndustries;
+using Microsoft.EntityFrameworkCore;
+using SeaHaven.DataServices.Interfaces;
+
+namespace SeaHaven.DataServices.Helpers
+{
+    public static class WorkOrderBoardProjection
+    {
+        public static async Task<IReadOnlyList<WorkOrderBoardRawRow>> ProjectRowsAsync(
+            IQueryable<WorkOrder> query,
+            bool isUnscheduled)
+        {
+            var rows = await query
+                .Select(w => new
+                {
+                    w.Id,
+                    w.InternalWONumber,
+                    w.RescheduleCount,
+                    w.CarriedOver,
+                    w.WorkOrderType,
+                    w.SiteCode,
+                    LocationName = w.Locations != null ? w.Locations.Name : null,
+                    WoPocName = w.PocName,
+                    WoPocPhone = w.PocPhone,
+                    WoPocNotes = w.PocNotes,
+                    ContactPoc = w.WorkOrderContacts!
+                        .OrderBy(c => c.Id)
+                        .Select(c => new
+                        {
+                            Name = c.POC != null
+                                ? ((c.POC.FirstName ?? "") + " " + (c.POC.LastName ?? "")).Trim()
+                                : null,
+                            c.POC!.PhoneNumber,
+                            c.Notes
+                        })
+                        .FirstOrDefault(),
+                    w.LifecycleStatus,
+                    w.LegacyStatus,
+                    w.Status,
+                    w.AssignTo,
+                    w.AssignToUser!.FirstName,
+                    w.AssignToUser!.LastName,
+                    w.AssignToUser!.Initials,
+                    w.AssignToUser!.Color,
+                    w.DueDate,
+                    w.ScheduledDate,
+                    w.ScheduledStart,
+                    w.ScheduledEnd,
+                    w.TargetWeek,
+                    w.ScheduleWeekOnly,
+                    VendorId = w.PrimaryDispatch != null ? (int?)w.PrimaryDispatch.VendorId : null,
+                    VendorName = w.PrimaryDispatch != null && w.PrimaryDispatch.Vendor != null
+                        ? w.PrimaryDispatch.Vendor.CompanyName
+                        : null,
+                    TechName = w.PrimaryDispatch != null && w.PrimaryDispatch.Vendor != null
+                        ? w.PrimaryDispatch.Vendor.ContactName
+                        : null,
+                    DispatchTechPhone = w.PrimaryDispatch != null ? w.PrimaryDispatch.TechPhone : null,
+                    WoTechPhone = w.TechPhone,
+                    VendorPhone = w.PrimaryDispatch != null && w.PrimaryDispatch.Vendor != null
+                        ? w.PrimaryDispatch.Vendor.Phone
+                        : null,
+                    DispatchApptDate = w.PrimaryDispatch != null ? w.PrimaryDispatch.ScheduledDate : null,
+                    w.Trade,
+                    w.Problem,
+                    w.ServiceNotes,
+                    w.ExtraServices,
+                    w.DocStatus,
+                    w.FlagColor,
+                    w.PrimaryDispatchId,
+                    w.RowVersion,
+                    DispatchRowVersion = w.PrimaryDispatch != null ? w.PrimaryDispatch.RowVersion : null
+                })
+                .ToListAsync();
+
+            return rows.Select(w =>
+            {
+                var pocName = !string.IsNullOrWhiteSpace(w.WoPocName) ? w.WoPocName : w.ContactPoc?.Name;
+                var pocPhone = !string.IsNullOrWhiteSpace(w.WoPocPhone) ? w.WoPocPhone : w.ContactPoc?.PhoneNumber;
+                var pocNotes = !string.IsNullOrWhiteSpace(w.WoPocNotes) ? w.WoPocNotes : w.ContactPoc?.Notes;
+                var techPhone = !string.IsNullOrWhiteSpace(w.DispatchTechPhone)
+                    ? w.DispatchTechPhone
+                    : (!string.IsNullOrWhiteSpace(w.WoTechPhone) ? w.WoTechPhone : w.VendorPhone);
+
+                return new WorkOrderBoardRawRow(
+                    w.Id,
+                    w.InternalWONumber,
+                    w.RescheduleCount,
+                    w.CarriedOver,
+                    w.WorkOrderType,
+                    w.SiteCode,
+                    w.LocationName,
+                    pocName,
+                    pocPhone,
+                    pocNotes,
+                    w.LifecycleStatus,
+                    w.LegacyStatus ?? w.Status,
+                    w.AssignTo,
+                    w.FirstName,
+                    w.LastName,
+                    w.Initials,
+                    w.Color,
+                    w.DueDate,
+                    w.ScheduledDate,
+                    w.ScheduledStart,
+                    w.ScheduledEnd,
+                    w.TargetWeek,
+                    w.ScheduleWeekOnly,
+                    w.VendorId,
+                    w.VendorName,
+                    w.TechName,
+                    techPhone,
+                    w.DispatchApptDate,
+                    w.Trade ?? w.Problem,
+                    w.Problem,
+                    w.ServiceNotes,
+                    w.ExtraServices,
+                    w.DocStatus,
+                    w.FlagColor,
+                    w.PrimaryDispatchId,
+                    w.RowVersion,
+                    w.DispatchRowVersion,
+                    isUnscheduled);
+            }).ToList();
+        }
+    }
+}
diff --git a/SeaHaven.DataServices/Helpers/WorkOrderBoardQueryFilters.cs b/SeaHaven.DataServices/Helpers/WorkOrderBoardQueryFilters.cs
new file mode 100644
index 0000000..46069db
--- /dev/null
+++ b/SeaHaven.DataServices/Helpers/WorkOrderBoardQueryFilters.cs
@@ -0,0 +1,174 @@
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+
+namespace SeaHaven.DataServices.Helpers
+{
+    public static class WorkOrderBoardQueryFilters
+    {
+        public static IQueryable<WorkOrder> ApplyBaseScope(IQueryable<WorkOrder> query)
+            => query.Where(w => w.istemplate != true && (w.IsDeleted != true || w.IsDeleted == null));
+
+        public static IQueryable<WorkOrder> ApplyDispatcherFilter(
+            IQueryable<WorkOrder> query,
+            IReadOnlyList<string>? dispatchers,
+            bool myWorkOrders,
+            string? currentUserId)
+        {
+            if (myWorkOrders && !string.IsNullOrEmpty(currentUserId))
+                return query.Where(w => w.AssignTo == currentUserId);
+
+            if (dispatchers == null || dispatchers.Count == 0)
+                return query;
+
+            var ids = dispatchers
+                .Where(d => d != "__unassigned__")
+                .ToList();
+            var includeUnassigned = dispatchers.Contains("__unassigned__");
+
+            if (includeUnassigned && ids.Count == 0)
+                return query.Where(w => w.AssignTo == null || w.AssignTo == "");
+
+            if (includeUnassigned && ids.Count > 0)
+            {
+                return query.Where(w =>
+                    w.AssignTo == null || w.AssignTo == "" || ids.Contains(w.AssignTo));
+            }
+
+            return query.Where(w => w.AssignTo != null && ids.Contains(w.AssignTo));
+        }
+
+        /// <summary>
+        /// FE sends <see cref="WorkOrderType.Other"/> (99) as the overdue/isPastDue sentinel — not a real type filter.
+        /// </summary>
+        public static IQueryable<WorkOrder> ApplyTypeAndOverdueFilter(
+            IQueryable<WorkOrder> query,
+            IReadOnlyList<WorkOrderType>? types,
+            DateTime? utcNow = null)
+        {
+            if (types == null || types.Count == 0)
+                return query;
+
+            var today = (utcNow ?? DateTime.UtcNow).Date;
+            var includeOverdue = types.Contains(WorkOrderType.Other);
+            var typeFilters = types.Where(t => t != WorkOrderType.Other).ToList();
+
+            // Keep past-due predicate inline — EF cannot translate local method calls.
+            if (includeOverdue && typeFilters.Count == 0)
+            {
+                return query.Where(w =>
+                    w.ScheduledDate != null
+                    && w.ScheduledDate.Value.Date < today
+                    && w.LifecycleStatus != LifecycleStatus.Completed
+                    && w.LifecycleStatus != LifecycleStatus.Canceled);
+            }
+
+            if (includeOverdue)
+            {
+                return query.Where(w =>
+                    (w.ScheduledDate != null
+                     && w.ScheduledDate.Value.Date < today
+                     && w.LifecycleStatus != LifecycleStatus.Completed
+                     && w.LifecycleStatus != LifecycleStatus.Canceled)
+                    || (w.WorkOrderType != null && typeFilters.Contains(w.WorkOrderType.Value)));
+            }
+
+            return query.Where(w => w.WorkOrderType != null && typeFilters.Contains(w.WorkOrderType.Value));
+        }
+
+        public static IQueryable<WorkOrder> ApplyTypeFilter(
+            IQueryable<WorkOrder> query,
+            IReadOnlyList<WorkOrderType>? types)
+            => ApplyTypeAndOverdueFilter(query, types);
+
+        public static IQueryable<WorkOrder> ApplySiteFilter(
+            IQueryable<WorkOrder> query,
+            IReadOnlyList<string>? sites)
+        {
+            if (sites == null || sites.Count == 0)
+                return query;
+
+            var normalized = sites
+                .Where(s => !string.IsNullOrWhiteSpace(s))
+                .Select(s => s.Trim())
+                .ToList();
+
+            if (normalized.Count == 0)
+                return query;
+
+            return query.Where(w => w.SiteCode != null && normalized.Contains(w.SiteCode));
+        }
+
+        public static IQueryable<WorkOrder> ApplyStatusFilter(
+            IQueryable<WorkOrder> query,
+            IReadOnlyList<LifecycleStatus>? statuses)
+        {
+            if (statuses == null || statuses.Count == 0)
+                return query;
+
+            return query.Where(w => w.LifecycleStatus != null && statuses.Contains(w.LifecycleStatus.Value));
+        }
+
+        public static IQueryable<WorkOrder> ApplyDocStatusFilter(
+            IQueryable<WorkOrder> query,
+            IReadOnlyList<DocStatus>? docStatuses)
+        {
+            if (docStatuses == null || docStatuses.Count == 0)
+                return query;
+
+            return query.Where(w => w.DocStatus != null && docStatuses.Contains(w.DocStatus.Value));
+        }
+
+        public static IQueryable<WorkOrder> ApplyVendorFilter(
+            IQueryable<WorkOrder> query,
+            IReadOnlyList<int>? vendorIds)
+        {
+            if (vendorIds == null || vendorIds.Count == 0)
+                return query;
+
+            return query.Where(w =>
+                w.PrimaryDispatch != null && vendorIds.Contains(w.PrimaryDispatch.VendorId));
+        }
+
+        public static IQueryable<WorkOrder> ApplyPmTypeFilter(
+            IQueryable<WorkOrder> query,
+            IReadOnlyList<string>? pmTypes)
+        {
+            if (pmTypes == null || pmTypes.Count == 0)
+                return query;
+
+            var normalized = pmTypes
+                .Where(p => !string.IsNullOrWhiteSpace(p))
+                .Select(p => p.Trim().ToLower())
+                .ToList();
+
+            if (normalized.Count == 0)
+                return query;
+
+            return query.Where(w =>
+                normalized.Any(pm =>
+                    (w.Trade ?? "").ToLower().Contains(pm)
+                    || (w.Problem ?? "").ToLower().Contains(pm)));
+        }
+
+        public static IQueryable<WorkOrder> ApplyDateRangeFilter(
+            IQueryable<WorkOrder> query,
+            DateOnly dateFrom,
+            DateOnly dateTo)
+        {
+            var fromDate = dateFrom.ToDateTime(TimeOnly.MinValue).Date;
+            var toDate = dateTo.ToDateTime(TimeOnly.MinValue).Date;
+
+            return query.Where(w =>
+                (w.ScheduledDate != null
+                 && w.ScheduledDate.Value.Date >= fromDate
+                 && w.ScheduledDate.Value.Date <= toDate)
+                || (w.ScheduleWeekOnly == true
+                    && w.TargetWeek != null
+                    && w.TargetWeek >= dateFrom
+                    && w.TargetWeek <= dateTo)
+                || (w.ScheduledDate == null
+                    && w.LifecycleStatus != LifecycleStatus.Completed
+                    && w.LifecycleStatus != LifecycleStatus.Canceled));
+        }
+    }
+}
diff --git a/SeaHaven.DataServices/Helpers/WorkOrderBoardSearchFilter.cs b/SeaHaven.DataServices/Helpers/WorkOrderBoardSearchFilter.cs
new file mode 100644
index 0000000..d6cf28d
--- /dev/null
+++ b/SeaHaven.DataServices/Helpers/WorkOrderBoardSearchFilter.cs
@@ -0,0 +1,133 @@
+using System.Globalization;
+using System.Text.RegularExpressions;
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+
+namespace SeaHaven.DataServices.Helpers
+{
+    public static class WorkOrderBoardSearchFilter
+    {
+        private static readonly Regex PartialDatePattern = new(
+            @"^\d{1,2}/\d{1,2}$",
+            RegexOptions.Compiled | RegexOptions.CultureInvariant);
+
+        public static string? NormalizeSearch(string? search)
+        {
+            if (string.IsNullOrWhiteSpace(search))
+                return null;
+
+            var trimmed = search.Trim();
+            return trimmed.Length < 2 ? null : trimmed;
+        }
+
+        public static IQueryable<WorkOrder> Apply(IQueryable<WorkOrder> query, string? search)
+        {
+            var normalized = NormalizeSearch(search);
+            if (normalized == null)
+                return query;
+
+            var s = normalized.ToLower();
+            var today = DateTime.UtcNow.Date;
+            var exactDate = TryParseExactDate(normalized);
+            var hasExactDate = exactDate.HasValue;
+            var exactDateValue = exactDate?.Date ?? default;
+
+            var partialMonthDay = TryParsePartialMonthDay(normalized);
+            var hasPartialMonthDay = partialMonthDay.HasValue;
+            var partialMonth = partialMonthDay?.Month ?? 0;
+            var partialDay = partialMonthDay?.Day ?? 0;
+
+            // Keep predicates inline — EF Core cannot translate local method calls.
+            return query.Where(w =>
+                (w.SiteCode ?? "").ToLower().Contains(s)
+                || (w.InternalWONumber ?? "").ToLower().Contains(s)
+                || (w.WorkerOrderNumber ?? "").ToLower().Contains(s)
+                || (w.WorkerOrderTitle ?? "").ToLower().Contains(s)
+                || (w.Description ?? "").ToLower().Contains(s)
+                || (w.Locations != null && (w.Locations.Name ?? "").ToLower().Contains(s))
+                || (w.AssignToUser != null && ((w.AssignToUser.FirstName ?? "") + " " + (w.AssignToUser.LastName ?? "")).ToLower().Contains(s))
+                || (w.Trade ?? "").ToLower().Contains(s)
+                || (w.Problem ?? "").ToLower().Contains(s)
+                || (w.PrimaryDispatch != null && w.PrimaryDispatch.Vendor != null && (w.PrimaryDispatch.Vendor.CompanyName ?? "").ToLower().Contains(s))
+                || (w.PrimaryDispatch != null && w.PrimaryDispatch.Vendor != null && (w.PrimaryDispatch.Vendor.ContactName ?? "").ToLower().Contains(s))
+                || (w.Status ?? "").ToLower().Contains(s)
+                || (w.WorkOrderType == WorkOrderType.PO && "po".Contains(s))
+                || (w.WorkOrderType == WorkOrderType.PM && "pm".Contains(s))
+                || (w.WorkOrderType == WorkOrderType.Emergency && "emergency".Contains(s))
+                || (w.WorkOrderType == WorkOrderType.Project && "project".Contains(s))
+                || (w.WorkOrderType == WorkOrderType.Inspection && "inspection".Contains(s))
+                || (w.WorkOrderType == WorkOrderType.Reactive && "reactive".Contains(s))
+                || (w.WorkOrderType == WorkOrderType.AddOn && ("add-on".Contains(s) || "addon".Contains(s)))
+                || (w.WorkOrderType == WorkOrderType.Other && "other".Contains(s))
+                || ("overdue".Contains(s)
+                    && w.ScheduledDate != null
+                    && w.ScheduledDate.Value.Date < today
+                    && w.LifecycleStatus != LifecycleStatus.Completed
+                    && w.LifecycleStatus != LifecycleStatus.Canceled)
+                || (w.LifecycleStatus == LifecycleStatus.Incomplete && "incomplete".Contains(s))
+                || (w.LifecycleStatus == LifecycleStatus.Pending && ("pending".Contains(s) || "on hold".Contains(s) || "onhold".Contains(s)))
+                || (w.LifecycleStatus == LifecycleStatus.Scheduled && "scheduled".Contains(s))
+                || (w.LifecycleStatus == LifecycleStatus.EnRoute && ("en route".Contains(s) || "enroute".Contains(s)))
+                || (w.LifecycleStatus == LifecycleStatus.OnSite && ("on site".Contains(s) || "onsite".Contains(s)))
+                || (w.LifecycleStatus == LifecycleStatus.InProgress && ("in progress".Contains(s) || "inprogress".Contains(s)))
+                || (w.LifecycleStatus == LifecycleStatus.Completed && ("completed".Contains(s) || "complete".Contains(s) || "done".Contains(s) || "closed".Contains(s)))
+                || (w.LifecycleStatus == LifecycleStatus.Rescheduled && "rescheduled".Contains(s))
+                || (w.LifecycleStatus == LifecycleStatus.Canceled && ("canceled".Contains(s) || "cancelled".Contains(s)))
+                || (w.LifecycleStatus == LifecycleStatus.PendingQuote && ("pending quote".Contains(s) || "pendingquote".Contains(s) || "pending approval".Contains(s) || "pendingapproval".Contains(s)))
+                || (hasExactDate
+                    && ((w.ScheduledDate != null && w.ScheduledDate.Value.Date == exactDateValue)
+                        || (w.DueDate != null && w.DueDate.Value.Date == exactDateValue)))
+                || (hasPartialMonthDay
+                    && ((w.ScheduledDate != null
+                         && w.ScheduledDate.Value.Month == partialMonth
+                         && w.ScheduledDate.Value.Day == partialDay)
+                        || (w.DueDate != null
+                            && w.DueDate.Value.Month == partialMonth
+                            && w.DueDate.Value.Day == partialDay))));
+        }
+
+        internal static DateTime? TryParseExactDate(string search)
+        {
+            if (PartialDatePattern.IsMatch(search))
+                return null;
+
+            var formats = new[]
+            {
+                "yyyy-MM-dd",
+                "MM/dd/yyyy",
+                "M/d/yyyy",
+                "MM/dd/yy",
+                "M/d/yy"
+            };
+
+            if (DateTime.TryParseExact(search, formats, CultureInfo.InvariantCulture, DateTimeStyles.None, out var parsed))
+                return parsed.Date;
+
+            if (DateTime.TryParse(search, CultureInfo.InvariantCulture, DateTimeStyles.None, out parsed))
+                return parsed.Date;
+
+            return null;
+        }
+
+        internal static (int Month, int Day)? TryParsePartialMonthDay(string search)
+        {
+            if (!PartialDatePattern.IsMatch(search))
+                return null;
+
+            var parts = search.Split('/');
+            if (parts.Length != 2)
+                return null;
+
+            if (!int.TryParse(parts[0], NumberStyles.None, CultureInfo.InvariantCulture, out var month))
+                return null;
+
+            if (!int.TryParse(parts[1], NumberStyles.None, CultureInfo.InvariantCulture, out var day))
+                return null;
+
+            if (month is < 1 or > 12 || day is < 1 or > 31)
+                return null;
+
+            return (month, day);
+        }
+    }
+}
diff --git a/SeaHaven.DataServices/Implementation/CompletionDocTemplateDataService.cs b/SeaHaven.DataServices/Implementation/CompletionDocTemplateDataService.cs
new file mode 100644
index 0000000..356b623
--- /dev/null
+++ b/SeaHaven.DataServices/Implementation/CompletionDocTemplateDataService.cs
@@ -0,0 +1,103 @@
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+using Microsoft.EntityFrameworkCore;
+using SeaHaven.DataServices.Interfaces;
+
+namespace SeaHaven.DataServices.Implementation
+{
+    public class CompletionDocTemplateDataService : ICompletionDocTemplateDataService
+    {
+        private readonly ApplicationDbContext _context;
+
+        public CompletionDocTemplateDataService(ApplicationDbContext context)
+        {
+            _context = context;
+        }
+
+        public async Task<IReadOnlyList<CompletionDocTemplateRow>> GetActiveAsync(string? serviceKey, WorkOrderType? workOrderType)
+        {
+            var query = _context.CompletionDocTemplates
+                .AsNoTracking()
+                .Where(t => t.IsActive && t.IsDeleted != true);
+
+            if (!string.IsNullOrWhiteSpace(serviceKey))
+                query = query.Where(t => t.ServiceKey == serviceKey);
+
+            if (workOrderType.HasValue)
+                query = query.Where(t => t.WorkOrderType == null || t.WorkOrderType == workOrderType);
+
+            return await query
+                .OrderBy(t => t.Name)
+                .Select(MapRow)
+                .ToListAsync();
+        }
+
+        public async Task<CompletionDocTemplateRow?> GetByIdAsync(int id)
+        {
+            return await _context.CompletionDocTemplates
+                .AsNoTracking()
+                .Where(t => t.Id == id && t.IsDeleted != true)
+                .Select(MapRow)
+                .FirstOrDefaultAsync();
+        }
+
+        public async Task<CompletionDocTemplateRow?> ResolveForWorkOrderAsync(string? trade, WorkOrderType? workOrderType)
+        {
+            if (!string.IsNullOrWhiteSpace(trade))
+            {
+                var byTrade = await _context.CompletionDocTemplates
+                    .AsNoTracking()
+                    .Where(t => t.IsActive && t.IsDeleted != true && t.ServiceKey == trade)
+                    .OrderBy(t => t.WorkOrderType == workOrderType ? 0 : 1)
+                    .ThenBy(t => t.Name)
+                    .ThenBy(t => t.Id)
+                    .Select(MapRow)
+                    .FirstOrDefaultAsync();
+
+                if (byTrade != null)
+                    return byTrade;
+            }
+
+            if (!workOrderType.HasValue)
+                return null;
+
+            return await _context.CompletionDocTemplates
+                .AsNoTracking()
+                .Where(t => t.IsActive && t.IsDeleted != true && t.WorkOrderType == workOrderType)
+                .OrderBy(t => t.Name)
+                .ThenBy(t => t.Id)
+                .Select(MapRow)
+                .FirstOrDefaultAsync();
+        }
+
+        public async Task<CompletionDocTemplate> CreateAsync(CompletionDocTemplate template)
+        {
+            template.CreatedDate = DateTime.UtcNow;
+            await _context.CompletionDocTemplates.AddAsync(template);
+            await _context.SaveChangesAsync();
+            return template;
+        }
+
+        public async Task UpdateAsync(CompletionDocTemplate template)
+        {
+            template.LastModificationTime = DateTime.UtcNow;
+            _context.CompletionDocTemplates.Update(template);
+            await _context.SaveChangesAsync();
+        }
+
+        public async Task<bool> DeleteAsync(int id)
+        {
+            var entity = await _context.CompletionDocTemplates.FindAsync(id);
+            if (entity == null)
+                return false;
+
+            entity.IsDeleted = true;
+            entity.DeletionTime = DateTime.UtcNow;
+            await _context.SaveChangesAsync();
+            return true;
+        }
+
+        private static readonly System.Linq.Expressions.Expression<Func<CompletionDocTemplate, CompletionDocTemplateRow>> MapRow =
+            t => new CompletionDocTemplateRow(t.Id, t.Name, t.ServiceKey, t.WorkOrderType, t.TemplateUrl, t.IsActive);
+    }
+}
diff --git a/SeaHaven.DataServices/Implementation/LocationDataService.cs b/SeaHaven.DataServices/Implementation/LocationDataService.cs
index 65c46df..b48cd5b 100644
--- a/SeaHaven.DataServices/Implementation/LocationDataService.cs
+++ b/SeaHaven.DataServices/Implementation/LocationDataService.cs
@@ -60,6 +60,24 @@ namespace SeaHaven.DataServices.Implementation
             return (items, totalCount);
         }
 
+        public async Task<IReadOnlyList<SiteOptionRow>> GetSiteOptionsAsync(string? search = null)
+        {
+            var query = _context.Locations.AsNoTracking();
+
+            if (!string.IsNullOrWhiteSpace(search))
+            {
+                var s = search.ToLower();
+                query = query.Where(l =>
+                    (l.Name ?? "").ToLower().Contains(s) ||
+                    (l.City ?? "").ToLower().Contains(s));
+            }
+
+            return await query
+                .OrderBy(l => l.Name)
+                .Select(l => new SiteOptionRow(l.Id, l.Name, l.City, l.State))
+                .ToListAsync();
+        }
+
         public async Task<Locations> AddAsync(Locations location)
         {
             location.CreatedDate = DateTime.Now;
diff --git a/SeaHaven.DataServices/Implementation/UserDataService.cs b/SeaHaven.DataServices/Implementation/UserDataService.cs
index 365ceca..436a806 100644
--- a/SeaHaven.DataServices/Implementation/UserDataService.cs
+++ b/SeaHaven.DataServices/Implementation/UserDataService.cs
@@ -33,5 +33,27 @@ namespace SeaHaven.DataServices.Implementation
         {
             return await _context.Users.AnyAsync(u => u.Id == id);
         }
+
+        public async Task<IReadOnlyDictionary<string, string>> GetDisplayNamesByIdsAsync(IEnumerable<string> ids)
+        {
+            var idList = ids
+                .Where(id => !string.IsNullOrWhiteSpace(id))
+                .Distinct(StringComparer.Ordinal)
+                .ToList();
+
+            if (idList.Count == 0)
+                return new Dictionary<string, string>(StringComparer.Ordinal);
+
+            var users = await _context.Users
+                .AsNoTracking()
+                .Where(u => idList.Contains(u.Id))
+                .Select(u => new { u.Id, u.FirstName, u.LastName })
+                .ToListAsync();
+
+            return users.ToDictionary(
+                u => u.Id,
+                u => $"{u.FirstName ?? ""} {u.LastName ?? ""}".Trim(),
+                StringComparer.Ordinal);
+        }
     }
 }
diff --git a/SeaHaven.DataServices/Implementation/WorkOrderAdvancedSearchDataService.cs b/SeaHaven.DataServices/Implementation/WorkOrderAdvancedSearchDataService.cs
new file mode 100644
index 0000000..d30cb49
--- /dev/null
+++ b/SeaHaven.DataServices/Implementation/WorkOrderAdvancedSearchDataService.cs
@@ -0,0 +1,64 @@
+using Data.SeaHavenIndustries;
+using Microsoft.EntityFrameworkCore;
+using SeaHaven.DataServices.Helpers;
+using SeaHaven.DataServices.Interfaces;
+
+namespace SeaHaven.DataServices.Implementation
+{
+    public class WorkOrderAdvancedSearchDataService : IWorkOrderAdvancedSearchDataService
+    {
+        private readonly ApplicationDbContext _context;
+
+        public WorkOrderAdvancedSearchDataService(ApplicationDbContext context)
+        {
+            _context = context;
+        }
+
+        public async Task<WorkOrderAdvancedSearchResult> SearchAsync(WorkOrderAdvancedSearchQuery query)
+        {
+            var baseQuery = WorkOrderBoardQueryFilters.ApplyBaseScope(_context.workOrders.AsNoTracking());
+            baseQuery = WorkOrderBoardQueryFilters.ApplyDateRangeFilter(baseQuery, query.DateFrom, query.DateTo);
+            baseQuery = WorkOrderBoardQueryFilters.ApplySiteFilter(baseQuery, query.Sites);
+            baseQuery = WorkOrderBoardQueryFilters.ApplyTypeFilter(baseQuery, query.Types);
+            baseQuery = WorkOrderBoardQueryFilters.ApplyDispatcherFilter(
+                baseQuery, query.Dispatchers, query.MyWorkOrders, query.CurrentUserId);
+            baseQuery = WorkOrderBoardQueryFilters.ApplyStatusFilter(baseQuery, query.Statuses);
+            baseQuery = WorkOrderBoardQueryFilters.ApplyPmTypeFilter(baseQuery, query.PmTypes);
+            baseQuery = WorkOrderBoardQueryFilters.ApplyVendorFilter(baseQuery, query.VendorIds);
+            baseQuery = WorkOrderBoardQueryFilters.ApplyDocStatusFilter(baseQuery, query.DocStatuses);
+
+            var normalizedSearch = WorkOrderBoardSearchFilter.NormalizeSearch(query.Search);
+            if (normalizedSearch != null)
+                baseQuery = WorkOrderBoardSearchFilter.Apply(baseQuery, normalizedSearch);
+
+            var totalCount = await baseQuery.CountAsync();
+
+            var sorted = ApplySort(baseQuery, query.SortBy, query.SortDir);
+            var paged = sorted
+                .Skip(query.Page * query.PageSize)
+                .Take(query.PageSize);
+
+            var rows = await WorkOrderBoardProjection.ProjectRowsAsync(paged, isUnscheduled: false);
+            return new WorkOrderAdvancedSearchResult(rows, totalCount);
+        }
+
+        private static IQueryable<WorkOrder> ApplySort(IQueryable<WorkOrder> query, string sortBy, string sortDir)
+        {
+            var descending = string.Equals(sortDir, "desc", StringComparison.OrdinalIgnoreCase);
+            var field = (sortBy ?? "scheduledDate").Trim().ToLowerInvariant();
+
+            return field switch
+            {
+                "wonumber" or "woNumber" => descending
+                    ? query.OrderByDescending(w => w.InternalWONumber)
+                    : query.OrderBy(w => w.InternalWONumber),
+                "duedate" or "dueDate" => descending
+                    ? query.OrderByDescending(w => w.DueDate).ThenBy(w => w.InternalWONumber)
+                    : query.OrderBy(w => w.DueDate).ThenBy(w => w.InternalWONumber),
+                _ => descending
+                    ? query.OrderByDescending(w => w.ScheduledDate).ThenByDescending(w => w.InternalWONumber)
+                    : query.OrderBy(w => w.ScheduledDate).ThenBy(w => w.InternalWONumber)
+            };
+        }
+    }
+}
diff --git a/SeaHaven.DataServices/Implementation/WorkOrderBoardDataService.cs b/SeaHaven.DataServices/Implementation/WorkOrderBoardDataService.cs
new file mode 100644
index 0000000..51936eb
--- /dev/null
+++ b/SeaHaven.DataServices/Implementation/WorkOrderBoardDataService.cs
@@ -0,0 +1,96 @@
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+using Microsoft.EntityFrameworkCore;
+using SeaHaven.DataServices.Helpers;
+using SeaHaven.DataServices.Interfaces;
+
+namespace SeaHaven.DataServices.Implementation
+{
+    public class WorkOrderBoardDataService : IWorkOrderBoardDataService
+    {
+        private readonly ApplicationDbContext _context;
+
+        public WorkOrderBoardDataService(ApplicationDbContext context)
+        {
+            _context = context;
+        }
+
+        public async Task<WorkOrderBoardQueryResult> GetBoardRowsAsync(WorkOrderBoardQuery query)
+        {
+            var weekStartDate = query.WeekStart.ToDateTime(TimeOnly.MinValue);
+            var weekEndDate = query.WeekEnd.ToDateTime(TimeOnly.MinValue);
+
+            var baseQuery = WorkOrderBoardQueryFilters.ApplyBaseScope(_context.workOrders.AsNoTracking());
+            baseQuery = WorkOrderBoardQueryFilters.ApplyDispatcherFilter(
+                baseQuery, query.Dispatchers, query.MyWorkOrders, query.CurrentUserId);
+            baseQuery = WorkOrderBoardQueryFilters.ApplyTypeFilter(baseQuery, query.Types);
+
+            var scheduledBase = baseQuery.Where(w =>
+                (w.ScheduledDate != null
+                 && w.ScheduledDate.Value.Date >= weekStartDate.Date
+                 && w.ScheduledDate.Value.Date <= weekEndDate.Date)
+                || (w.ScheduleWeekOnly == true && w.TargetWeek == query.WeekStart));
+
+            var unscheduledBase = baseQuery.Where(w =>
+                w.ScheduledDate == null
+                && w.LifecycleStatus != LifecycleStatus.Completed
+                && w.LifecycleStatus != LifecycleStatus.Canceled);
+
+            var scheduledTotal = await scheduledBase.CountAsync();
+
+            var normalizedSearch = WorkOrderBoardSearchFilter.NormalizeSearch(query.Search);
+            if (normalizedSearch != null)
+            {
+                scheduledBase = WorkOrderBoardSearchFilter.Apply(scheduledBase, normalizedSearch);
+                unscheduledBase = WorkOrderBoardSearchFilter.Apply(unscheduledBase, normalizedSearch);
+            }
+
+            var scheduledRows = await WorkOrderBoardProjection.ProjectRowsAsync(
+                scheduledBase.OrderBy(w => w.ScheduledDate).ThenBy(w => w.InternalWONumber),
+                isUnscheduled: false);
+            var unscheduledRows = await WorkOrderBoardProjection.ProjectRowsAsync(
+                unscheduledBase.OrderBy(w => w.InternalWONumber),
+                isUnscheduled: true);
+
+            return new WorkOrderBoardQueryResult(scheduledRows, unscheduledRows, scheduledTotal);
+        }
+
+        public async Task<IReadOnlyList<DispatcherLookupRow>> GetDispatcherLookupsAsync()
+        {
+            return await _context.Users
+                .AsNoTracking()
+                .Where(u => u.IsDeleted != true)
+                .OrderBy(u => u.FirstName)
+                .ThenBy(u => u.LastName)
+                .Select(u => new DispatcherLookupRow(
+                    u.Id,
+                    u.FirstName ?? "",
+                    u.LastName,
+                    u.Initials,
+                    u.Color))
+                .ToListAsync();
+        }
+
+        public async Task<WorkOrderBoardRawRow?> GetBoardRowByIdAsync(int workOrderId)
+        {
+            var query = _context.workOrders
+                .AsNoTracking()
+                .Where(w => w.Id == workOrderId && w.istemplate != true && (w.IsDeleted != true || w.IsDeleted == null));
+
+            var rows = await WorkOrderBoardProjection.ProjectRowsAsync(query, isUnscheduled: false);
+            return rows.FirstOrDefault();
+        }
+
+        public async Task<bool> InternalWoNumberExistsAsync(string normalizedWoNumber, int excludeWorkOrderId)
+        {
+            return await _context.workOrders
+                .AsNoTracking()
+                .AnyAsync(w =>
+                    w.Id != excludeWorkOrderId
+                    && w.istemplate != true
+                    && (w.IsDeleted != true || w.IsDeleted == null)
+                    && w.InternalWONumber == normalizedWoNumber);
+        }
+
+    }
+}
diff --git a/SeaHaven.DataServices/Implementation/WorkOrderDetailDataService.cs b/SeaHaven.DataServices/Implementation/WorkOrderDetailDataService.cs
new file mode 100644
index 0000000..e2526ab
--- /dev/null
+++ b/SeaHaven.DataServices/Implementation/WorkOrderDetailDataService.cs
@@ -0,0 +1,95 @@
+using Data.SeaHavenIndustries;
+using Microsoft.EntityFrameworkCore;
+using SeaHaven.DataServices.Helpers;
+using SeaHaven.DataServices.Interfaces;
+
+namespace SeaHaven.DataServices.Implementation
+{
+    public class WorkOrderDetailDataService : IWorkOrderDetailDataService
+    {
+        private readonly ApplicationDbContext _context;
+
+        public WorkOrderDetailDataService(ApplicationDbContext context)
+        {
+            _context = context;
+        }
+
+        public Task<bool> ExistsAsync(int workOrderId)
+            => WorkOrderBoardQueryFilters.ApplyBaseScope(_context.workOrders.AsNoTracking())
+                .AnyAsync(w => w.Id == workOrderId);
+
+        public async Task<WorkOrderDetailExtendedFields?> GetExtendedFieldsAsync(int workOrderId)
+        {
+            return await WorkOrderBoardQueryFilters.ApplyBaseScope(_context.workOrders.AsNoTracking())
+                .Where(w => w.Id == workOrderId)
+                .Select(w => new WorkOrderDetailExtendedFields(
+                    w.Description,
+                    w.Trade,
+                    w.Problem,
+                    w.SubTrade,
+                    w.OriginalWeek,
+                    w.OriginalDate,
+                    w.CompletedDate,
+                    w.SignOffName,
+                    w.SignOffAttachment,
+                    w.SignOffSignature,
+                    w.ExtraServices,
+                    w.ServiceNotes,
+                    w.PrimaryDispatch != null && w.PrimaryDispatch.VendorNotes != null
+                        ? w.PrimaryDispatch.VendorNotes
+                        : w.VendorNotes))
+                .FirstOrDefaultAsync();
+        }
+
+        public async Task<IReadOnlyList<Comments>> GetCommentsAsync(int workOrderId)
+        {
+            return await _context.Comments
+                .AsNoTracking()
+                .Where(c => c.WorkerOrderId == workOrderId && c.IsDeleted != true)
+                .OrderByDescending(c => c.CreatedDate)
+                .ToListAsync();
+        }
+
+        public async Task<IReadOnlyList<WorkOrderAuditLog>> GetAuditLogsAsync(int workOrderId, int? limit = null)
+        {
+            var query = _context.WorkOrderAuditLogs
+                .AsNoTracking()
+                .Where(a => a.WorkOrderId == workOrderId)
+                .OrderByDescending(a => a.CreatedAt);
+
+            if (limit.HasValue)
+                return await query.Take(limit.Value).ToListAsync();
+
+            return await query.ToListAsync();
+        }
+
+        public async Task<IReadOnlyList<WorkOrderAttachments>> GetAttachmentsAsync(int workOrderId)
+        {
+            return await _context.workOrderAttachments
+                .AsNoTracking()
+                .Where(a => a.WorkorderId == workOrderId && a.IsDeleted != true)
+                .OrderByDescending(a => a.CreatedDate)
+                .ToListAsync();
+        }
+
+        public async Task<IReadOnlyList<DispatchSignoffRow>> GetDispatchSignoffsAsync(int workOrderId)
+        {
+            return await _context.DispatchSignoffs
+                .AsNoTracking()
+                .Where(s => s.Dispatch != null && s.Dispatch.WorkOrderId == workOrderId && s.IsDeleted != true)
+                .OrderByDescending(s => s.SignedAt)
+                .Select(s => new DispatchSignoffRow(
+                    s.DispatchId,
+                    s.SignoffType,
+                    s.Name,
+                    s.SignedAt))
+                .ToListAsync();
+        }
+
+        public async Task<WorkOrder?> GetWorkOrderForMediaAsync(int workOrderId)
+        {
+            return await WorkOrderBoardQueryFilters.ApplyBaseScope(_context.workOrders.AsNoTracking())
+                .FirstOrDefaultAsync(w => w.Id == workOrderId);
+        }
+    }
+}
diff --git a/SeaHaven.DataServices/Implementation/WorkOrderDomainJobDataService.cs b/SeaHaven.DataServices/Implementation/WorkOrderDomainJobDataService.cs
new file mode 100644
index 0000000..65d98bc
--- /dev/null
+++ b/SeaHaven.DataServices/Implementation/WorkOrderDomainJobDataService.cs
@@ -0,0 +1,166 @@
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+using Microsoft.EntityFrameworkCore;
+using SeaHaven.DataServices.Interfaces;
+
+namespace SeaHaven.DataServices.Implementation
+{
+    public class WorkOrderDomainJobDataService : IWorkOrderDomainJobDataService
+    {
+        private static readonly LifecycleStatus?[] TerminalStatuses =
+        {
+            LifecycleStatus.Completed,
+            LifecycleStatus.Canceled
+        };
+
+        private readonly ApplicationDbContext _context;
+
+        public WorkOrderDomainJobDataService(ApplicationDbContext context)
+        {
+            _context = context;
+        }
+
+        public async Task<IReadOnlyList<int>> GetWeekRolledCandidatesAsync(
+            DateOnly sourceWeekStart,
+            DateOnly sourceWeekEnd,
+            int batchSize = 500,
+            CancellationToken cancellationToken = default)
+        {
+            var weekStartDate = sourceWeekStart.ToDateTime(TimeOnly.MinValue);
+            var weekEndDate = sourceWeekEnd.ToDateTime(TimeOnly.MinValue);
+
+            // Always return the first page of remaining unprocessed candidates.
+            // Callers must not offset-page: ledger writes shrink this set after each batch.
+            return await _context.workOrders
+                .AsNoTracking()
+                .Where(w => w.IsDeleted != true)
+                .Where(w => w.istemplate != true)
+                .Where(w => w.ScheduledDate != null)
+                .Where(w =>
+                    w.ScheduledDate!.Value.Date >= weekStartDate.Date
+                    && w.ScheduledDate.Value.Date <= weekEndDate.Date)
+                .Where(w => !TerminalStatuses.Contains(w.LifecycleStatus))
+                .Where(w => !_context.WorkOrderWeekRolledLedgers.Any(l =>
+                    l.WorkOrderId == w.Id && l.SourceWeekStart == sourceWeekStart))
+                .OrderBy(w => w.Id)
+                .Take(batchSize)
+                .Select(w => w.Id)
+                .ToListAsync(cancellationToken);
+        }
+
+        public async Task<WeekRolledProcessOutcome> TryProcessWeekRolledAsync(
+            int workOrderId,
+            DateOnly sourceWeekStart,
+            string correlationId,
+            CancellationToken cancellationToken = default)
+        {
+            await using var transaction = await _context.Database.BeginTransactionAsync(cancellationToken);
+
+            var alreadyProcessed = await _context.WorkOrderWeekRolledLedgers
+                .AnyAsync(l => l.WorkOrderId == workOrderId && l.SourceWeekStart == sourceWeekStart, cancellationToken);
+
+            if (alreadyProcessed)
+            {
+                await transaction.RollbackAsync(cancellationToken);
+                return new WeekRolledProcessOutcome { Skipped = true };
+            }
+
+            var workOrder = await _context.workOrders
+                .FirstOrDefaultAsync(w => w.Id == workOrderId, cancellationToken);
+
+            if (workOrder == null)
+            {
+                await transaction.RollbackAsync(cancellationToken);
+                return new WeekRolledProcessOutcome { Skipped = true };
+            }
+
+            _context.WorkOrderWeekRolledLedgers.Add(new WorkOrderWeekRolledLedger
+            {
+                WorkOrderId = workOrderId,
+                SourceWeekStart = sourceWeekStart,
+                ProcessedAt = DateTime.UtcNow,
+                CorrelationId = correlationId
+            });
+
+            var oldCarriedOver = workOrder.CarriedOver;
+            workOrder.CarriedOver = oldCarriedOver + 1;
+
+            try
+            {
+                await _context.SaveChangesAsync(cancellationToken);
+                await transaction.CommitAsync(cancellationToken);
+            }
+            catch (DbUpdateException)
+            {
+                await transaction.RollbackAsync(cancellationToken);
+                return new WeekRolledProcessOutcome { Skipped = true };
+            }
+
+            return new WeekRolledProcessOutcome
+            {
+                Processed = true,
+                OldCarriedOver = oldCarriedOver,
+                NewCarriedOver = workOrder.CarriedOver
+            };
+        }
+
+        public async Task<PastDueRefreshResult> RefreshPastDueFlagsAsync(
+            DateTime utcNow,
+            int batchSize = 500,
+            CancellationToken cancellationToken = default)
+        {
+            var today = utcNow.Date;
+            var setCount = 0;
+            var clearedCount = 0;
+            var examinedCount = 0;
+            var skip = 0;
+
+            while (true)
+            {
+                var batch = await _context.workOrders
+                    .Where(w => w.IsDeleted != true)
+                    .Where(w => w.istemplate != true)
+                    .Where(w => w.ScheduledDate != null)
+                    .OrderBy(w => w.Id)
+                    .Skip(skip)
+                    .Take(batchSize)
+                    .ToListAsync(cancellationToken);
+
+                if (batch.Count == 0)
+                    break;
+
+                foreach (var workOrder in batch)
+                {
+                    examinedCount++;
+                    var shouldBePastDue = workOrder.ScheduledDate!.Value.Date < today
+                        && !TerminalStatuses.Contains(workOrder.LifecycleStatus);
+                    var hasFlag = workOrder.OperationalFlags.HasFlag(OperationalFlags.PastDue);
+
+                    if (shouldBePastDue && !hasFlag)
+                    {
+                        workOrder.OperationalFlags |= OperationalFlags.PastDue;
+                        setCount++;
+                    }
+                    else if (!shouldBePastDue && hasFlag)
+                    {
+                        workOrder.OperationalFlags &= ~OperationalFlags.PastDue;
+                        clearedCount++;
+                    }
+                }
+
+                await _context.SaveChangesAsync(cancellationToken);
+                skip += batchSize;
+
+                if (batch.Count < batchSize)
+                    break;
+            }
+
+            return new PastDueRefreshResult
+            {
+                SetCount = setCount,
+                ClearedCount = clearedCount,
+                ExaminedCount = examinedCount
+            };
+        }
+    }
+}
diff --git a/SeaHaven.DataServices/Interfaces/ILocationDataService.cs b/SeaHaven.DataServices/Interfaces/ILocationDataService.cs
index 2865e42..679528e 100644
--- a/SeaHaven.DataServices/Interfaces/ILocationDataService.cs
+++ b/SeaHaven.DataServices/Interfaces/ILocationDataService.cs
@@ -2,6 +2,8 @@ using Data.SeaHavenIndustries;
 
 namespace SeaHaven.DataServices.Interfaces
 {
+    public record SiteOptionRow(int Id, string? Code, string? City, string? State);
+
     public interface ILocationDataService
     {
         Task<Locations?> GetByIdAsync(int id);
@@ -15,6 +17,8 @@ namespace SeaHaven.DataServices.Interfaces
         // For addressbook endpoint - returns simplified DTO
         Task<(IEnumerable<object> Items, int TotalCount)> GetAddressbookPagedAsync(int page, int pageSize, string? search = null);
 
+        Task<IReadOnlyList<SiteOptionRow>> GetSiteOptionsAsync(string? search = null);
+
         Task<Locations> AddAsync(Locations location);
         Task UpdateAsync(Locations location);
         Task DeleteAsync(int id);
diff --git a/SeaHaven.DataServices/Interfaces/IUserDataService.cs b/SeaHaven.DataServices/Interfaces/IUserDataService.cs
index 6524cc4..6cfed2d 100644
--- a/SeaHaven.DataServices/Interfaces/IUserDataService.cs
+++ b/SeaHaven.DataServices/Interfaces/IUserDataService.cs
@@ -8,5 +8,6 @@ namespace SeaHaven.DataServices.Interfaces
         Task<IEnumerable<ApplicationUser>> GetAllAsync();
         Task<ApplicationUser?> GetByEmailAsync(string email);
         Task<bool> ExistsAsync(string id);
+        Task<IReadOnlyDictionary<string, string>> GetDisplayNamesByIdsAsync(IEnumerable<string> ids);
     }
 }
diff --git a/SeaHaven.DataServices/Interfaces/IWorkOrderAdvancedSearchDataService.cs b/SeaHaven.DataServices/Interfaces/IWorkOrderAdvancedSearchDataService.cs
new file mode 100644
index 0000000..f758550
--- /dev/null
+++ b/SeaHaven.DataServices/Interfaces/IWorkOrderAdvancedSearchDataService.cs
@@ -0,0 +1,9 @@
+using SeaHaven.DataServices.Interfaces;
+
+namespace SeaHaven.DataServices.Interfaces
+{
+    public interface IWorkOrderAdvancedSearchDataService
+    {
+        Task<WorkOrderAdvancedSearchResult> SearchAsync(WorkOrderAdvancedSearchQuery query);
+    }
+}
diff --git a/SeaHaven.DataServices/Interfaces/IWorkOrderBoardDataService.cs b/SeaHaven.DataServices/Interfaces/IWorkOrderBoardDataService.cs
new file mode 100644
index 0000000..4f23d5a
--- /dev/null
+++ b/SeaHaven.DataServices/Interfaces/IWorkOrderBoardDataService.cs
@@ -0,0 +1,12 @@
+using SeaHaven.DataServices.Interfaces;
+
+namespace SeaHaven.DataServices.Interfaces
+{
+    public interface IWorkOrderBoardDataService
+    {
+        Task<WorkOrderBoardQueryResult> GetBoardRowsAsync(WorkOrderBoardQuery query);
+        Task<IReadOnlyList<DispatcherLookupRow>> GetDispatcherLookupsAsync();
+        Task<WorkOrderBoardRawRow?> GetBoardRowByIdAsync(int workOrderId);
+        Task<bool> InternalWoNumberExistsAsync(string normalizedWoNumber, int excludeWorkOrderId);
+    }
+}
diff --git a/SeaHaven.DataServices/Interfaces/IWorkOrderDetailDataService.cs b/SeaHaven.DataServices/Interfaces/IWorkOrderDetailDataService.cs
new file mode 100644
index 0000000..3f61a70
--- /dev/null
+++ b/SeaHaven.DataServices/Interfaces/IWorkOrderDetailDataService.cs
@@ -0,0 +1,27 @@
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+using SeaHaven.DataServices.Interfaces;
+
+namespace SeaHaven.DataServices.Interfaces
+{
+    public interface IWorkOrderDetailDataService
+    {
+        Task<bool> ExistsAsync(int workOrderId);
+        Task<WorkOrderDetailExtendedFields?> GetExtendedFieldsAsync(int workOrderId);
+        Task<IReadOnlyList<Comments>> GetCommentsAsync(int workOrderId);
+        Task<IReadOnlyList<WorkOrderAuditLog>> GetAuditLogsAsync(int workOrderId, int? limit = null);
+        Task<IReadOnlyList<WorkOrderAttachments>> GetAttachmentsAsync(int workOrderId);
+        Task<IReadOnlyList<DispatchSignoffRow>> GetDispatchSignoffsAsync(int workOrderId);
+        Task<WorkOrder?> GetWorkOrderForMediaAsync(int workOrderId);
+    }
+
+    public interface ICompletionDocTemplateDataService
+    {
+        Task<IReadOnlyList<CompletionDocTemplateRow>> GetActiveAsync(string? serviceKey, WorkOrderType? workOrderType);
+        Task<CompletionDocTemplateRow?> GetByIdAsync(int id);
+        Task<CompletionDocTemplateRow?> ResolveForWorkOrderAsync(string? trade, WorkOrderType? workOrderType);
+        Task<CompletionDocTemplate> CreateAsync(CompletionDocTemplate template);
+        Task UpdateAsync(CompletionDocTemplate template);
+        Task<bool> DeleteAsync(int id);
+    }
+}
diff --git a/SeaHaven.DataServices/Interfaces/IWorkOrderDomainJobDataService.cs b/SeaHaven.DataServices/Interfaces/IWorkOrderDomainJobDataService.cs
new file mode 100644
index 0000000..5fac4ba
--- /dev/null
+++ b/SeaHaven.DataServices/Interfaces/IWorkOrderDomainJobDataService.cs
@@ -0,0 +1,37 @@
+namespace SeaHaven.DataServices.Interfaces
+{
+    public sealed class WeekRolledProcessOutcome
+    {
+        public bool Processed { get; init; }
+        public bool Skipped { get; init; }
+        public int OldCarriedOver { get; init; }
+        public int NewCarriedOver { get; init; }
+    }
+
+    public sealed class PastDueRefreshResult
+    {
+        public int SetCount { get; init; }
+        public int ClearedCount { get; init; }
+        public int ExaminedCount { get; init; }
+    }
+
+    public interface IWorkOrderDomainJobDataService
+    {
+        Task<IReadOnlyList<int>> GetWeekRolledCandidatesAsync(
+            DateOnly sourceWeekStart,
+            DateOnly sourceWeekEnd,
+            int batchSize = 500,
+            CancellationToken cancellationToken = default);
+
+        Task<WeekRolledProcessOutcome> TryProcessWeekRolledAsync(
+            int workOrderId,
+            DateOnly sourceWeekStart,
+            string correlationId,
+            CancellationToken cancellationToken = default);
+
+        Task<PastDueRefreshResult> RefreshPastDueFlagsAsync(
+            DateTime utcNow,
+            int batchSize = 500,
+            CancellationToken cancellationToken = default);
+    }
+}
diff --git a/SeaHaven.DataServices/Interfaces/PrimaryDispatchProjection.cs b/SeaHaven.DataServices/Interfaces/PrimaryDispatchProjection.cs
new file mode 100644
index 0000000..ce6ebf6
--- /dev/null
+++ b/SeaHaven.DataServices/Interfaces/PrimaryDispatchProjection.cs
@@ -0,0 +1,9 @@
+namespace SeaHaven.DataServices.Interfaces
+{
+    public record PrimaryDispatchProjection(
+        int WorkOrderId,
+        int? DispatchId,
+        string? VendorName,
+        DateTime? ApptDate,
+        string? DispatchStatus);
+}
diff --git a/SeaHaven.DataServices/Interfaces/WorkOrderAdvancedSearchModels.cs b/SeaHaven.DataServices/Interfaces/WorkOrderAdvancedSearchModels.cs
new file mode 100644
index 0000000..0cede89
--- /dev/null
+++ b/SeaHaven.DataServices/Interfaces/WorkOrderAdvancedSearchModels.cs
@@ -0,0 +1,27 @@
+using Data.SeaHavenIndustries.Enums;
+using SeaHaven.DataServices.Interfaces;
+
+namespace SeaHaven.DataServices.Interfaces
+{
+    public record WorkOrderAdvancedSearchQuery(
+        string? Search,
+        DateOnly DateFrom,
+        DateOnly DateTo,
+        IReadOnlyList<string>? Sites,
+        IReadOnlyList<WorkOrderType>? Types,
+        IReadOnlyList<string>? Dispatchers,
+        IReadOnlyList<LifecycleStatus>? Statuses,
+        IReadOnlyList<string>? PmTypes,
+        IReadOnlyList<int>? VendorIds,
+        IReadOnlyList<DocStatus>? DocStatuses,
+        bool MyWorkOrders,
+        string? CurrentUserId,
+        int Page,
+        int PageSize,
+        string SortBy,
+        string SortDir);
+
+    public record WorkOrderAdvancedSearchResult(
+        IReadOnlyList<WorkOrderBoardRawRow> Rows,
+        int TotalCount);
+}
diff --git a/SeaHaven.DataServices/Interfaces/WorkOrderBoardModels.cs b/SeaHaven.DataServices/Interfaces/WorkOrderBoardModels.cs
new file mode 100644
index 0000000..c46ff55
--- /dev/null
+++ b/SeaHaven.DataServices/Interfaces/WorkOrderBoardModels.cs
@@ -0,0 +1,65 @@
+using Data.SeaHavenIndustries.Enums;
+
+namespace SeaHaven.DataServices.Interfaces
+{
+    public record WorkOrderBoardQuery(
+        DateOnly WeekStart,
+        DateOnly WeekEnd,
+        IReadOnlyList<string>? Dispatchers,
+        bool MyWorkOrders,
+        IReadOnlyList<WorkOrderType>? Types,
+        string? Search,
+        string? CurrentUserId);
+
+    public record WorkOrderBoardRawRow(
+        int Id,
+        string? InternalWONumber,
+        int RescheduleCount,
+        int CarriedOver,
+        WorkOrderType? WorkOrderType,
+        string? SiteCode,
+        string? LocationName,
+        string? PocName,
+        string? PocPhone,
+        string? PocNotes,
+        LifecycleStatus? LifecycleStatus,
+        string? LegacyStatus,
+        string? AssignTo,
+        string? DispatcherFirstName,
+        string? DispatcherLastName,
+        string? Initials,
+        string? Color,
+        DateTime? DueDate,
+        DateTime? ScheduledDate,
+        DateTime? ScheduledStart,
+        DateTime? ScheduledEnd,
+        DateOnly? TargetWeek,
+        bool? ScheduleWeekOnly,
+        int? VendorId,
+        string? VendorName,
+        string? TechName,
+        string? TechPhone,
+        DateTime? DispatchApptDate,
+        string? Trade,
+        string? Problem,
+        string? ServiceNotes,
+        string? ExtraServices,
+        DocStatus? DocStatus,
+        string? FlagColor,
+        int? PrimaryDispatchId,
+        byte[]? RowVersion,
+        byte[]? DispatchRowVersion,
+        bool IsUnscheduled);
+
+    public record WorkOrderBoardQueryResult(
+        IReadOnlyList<WorkOrderBoardRawRow> ScheduledRows,
+        IReadOnlyList<WorkOrderBoardRawRow> UnscheduledRows,
+        int ScheduledTotalBeforeSearch);
+
+    public record DispatcherLookupRow(
+        string Id,
+        string FirstName,
+        string? LastName,
+        string? Initials,
+        string? Color);
+}
diff --git a/SeaHaven.DataServices/Interfaces/WorkOrderDetailModels.cs b/SeaHaven.DataServices/Interfaces/WorkOrderDetailModels.cs
new file mode 100644
index 0000000..433b080
--- /dev/null
+++ b/SeaHaven.DataServices/Interfaces/WorkOrderDetailModels.cs
@@ -0,0 +1,33 @@
+using Data.SeaHavenIndustries.Enums;
+
+namespace SeaHaven.DataServices.Interfaces
+{
+    public record WorkOrderDetailExtendedFields(
+        string? Description,
+        string? Trade,
+        string? Problem,
+        string? SubTrade,
+        DateOnly? OriginalWeek,
+        DateOnly? OriginalDate,
+        DateTime? CompletedDate,
+        string? SignOffName,
+        string? SignOffAttachment,
+        string? SignOffSignature,
+        string? ExtraServices,
+        string? ServiceNotes,
+        string? VendorNotes);
+
+    public record DispatchSignoffRow(
+        int DispatchId,
+        string? SignoffType,
+        string? Name,
+        DateTime? SignedAt);
+
+    public record CompletionDocTemplateRow(
+        int Id,
+        string Name,
+        string ServiceKey,
+        WorkOrderType? WorkOrderType,
+        string TemplateUrl,
+        bool IsActive);
+}
diff --git a/SeaHaven.Services.Tests/PagedResultTests.cs b/SeaHaven.Services.Tests/PagedResultTests.cs
index 911370e..6621180 100644
--- a/SeaHaven.Services.Tests/PagedResultTests.cs
+++ b/SeaHaven.Services.Tests/PagedResultTests.cs
@@ -8,8 +8,9 @@ public class PagedResultTests
 {
     [Theory]
     [InlineData(0, 10, 0)]
+    [InlineData(1, 10, 1)]
     [InlineData(10, 10, 1)]
-    [InlineData(25, 10, 3)]
+    [InlineData(11, 10, 2)]
     [InlineData(100, 25, 4)]
     public void TotalPages_IsCeilingOfCountOverPageSize(int totalCount, int pageSize, int expectedPages)
     {
@@ -19,16 +20,32 @@ public class PagedResultTests
     }
 
     [Fact]
-    public void HasPrevious_IsFalseOnFirstPage_TrueAfterward()
+    public void HasPrevious_IsFalseOnFirstPage_TrueAfterward_OneBased()
     {
         new PagedResult<string> { Page = 1, PageSize = 10, TotalCount = 30 }.HasPrevious.Should().BeFalse();
         new PagedResult<string> { Page = 2, PageSize = 10, TotalCount = 30 }.HasPrevious.Should().BeTrue();
     }
 
     [Fact]
-    public void HasNext_IsTrueBeforeLastPage_FalseOnLastPage()
+    public void HasNext_IsTrueBeforeLastPage_FalseOnLastPage_OneBased()
     {
         new PagedResult<string> { Page = 2, PageSize = 10, TotalCount = 30 }.HasNext.Should().BeTrue();
         new PagedResult<string> { Page = 3, PageSize = 10, TotalCount = 30 }.HasNext.Should().BeFalse();
     }
+
+    [Fact]
+    public void HasPrevious_And_HasNext_ZeroBased_WhenPageBaseIsZero()
+    {
+        var first = new PagedResult<string> { Page = 0, PageSize = 10, TotalCount = 30, PageBase = 0 };
+        first.HasPrevious.Should().BeFalse();
+        first.HasNext.Should().BeTrue();
+
+        var middle = new PagedResult<string> { Page = 1, PageSize = 10, TotalCount = 30, PageBase = 0 };
+        middle.HasPrevious.Should().BeTrue();
+        middle.HasNext.Should().BeTrue();
+
+        var last = new PagedResult<string> { Page = 2, PageSize = 10, TotalCount = 30, PageBase = 0 };
+        last.HasPrevious.Should().BeTrue();
+        last.HasNext.Should().BeFalse();
+    }
 }
diff --git a/SeaHaven.Services/Board/WorkOrderBoardConstants.cs b/SeaHaven.Services/Board/WorkOrderBoardConstants.cs
new file mode 100644
index 0000000..a00f3e2
--- /dev/null
+++ b/SeaHaven.Services/Board/WorkOrderBoardConstants.cs
@@ -0,0 +1,8 @@
+namespace SeaHaven.Services.Board
+{
+    public static class WorkOrderBoardConstants
+    {
+        public const int MaxWindowDays = 90;
+        public const int ClientSideThreshold = 300;
+    }
+}
diff --git a/SeaHaven.Services/Constants/WorkOrderFieldNames.cs b/SeaHaven.Services/Constants/WorkOrderFieldNames.cs
new file mode 100644
index 0000000..967e102
--- /dev/null
+++ b/SeaHaven.Services/Constants/WorkOrderFieldNames.cs
@@ -0,0 +1,26 @@
+namespace SeaHaven.Services.Constants
+{
+    public static class WorkOrderFieldNames
+    {
+        public const string LifecycleStatus = nameof(LifecycleStatus);
+        public const string AssignTo = nameof(AssignTo);
+        public const string ScheduledDate = nameof(ScheduledDate);
+        public const string ScheduledEnd = nameof(ScheduledEnd);
+        public const string TargetWeek = nameof(TargetWeek);
+        public const string ScheduleWeekOnly = nameof(ScheduleWeekOnly);
+        public const string DueDate = nameof(DueDate);
+        public const string Description = nameof(Description);
+        public const string WorkerOrderTitle = nameof(WorkerOrderTitle);
+        public const string SiteCode = nameof(SiteCode);
+        public const string Building = nameof(Building);
+        public const string LocationId = nameof(LocationId);
+        public const string WorkOrderType = nameof(WorkOrderType);
+        public const string Service = nameof(Service);
+        public const string DocStatus = nameof(DocStatus);
+        public const string Trade = nameof(Trade);
+        public const string Problem = nameof(Problem);
+        public const string Priority = nameof(Priority);
+        public const string InternalWONumber = nameof(InternalWONumber);
+        public const string Status = nameof(Status);
+    }
+}
diff --git a/SeaHaven.Services/DTOs/ContactDTOs.cs b/SeaHaven.Services/DTOs/ContactDTOs.cs
index 90cafc9..8710ecc 100644
--- a/SeaHaven.Services/DTOs/ContactDTOs.cs
+++ b/SeaHaven.Services/DTOs/ContactDTOs.cs
@@ -48,8 +48,17 @@ namespace SeaHaven.Services.DTOs
         public int TotalCount { get; set; }
         public int Page { get; set; }
         public int PageSize { get; set; }
-        public int TotalPages => (int)Math.Ceiling(TotalCount / (double)PageSize);
-        public bool HasPrevious => Page > 1;
-        public bool HasNext => Page < TotalPages;
+
+        /// <summary>
+        /// Page numbering base for <see cref="HasPrevious"/> / <see cref="HasNext"/>.
+        /// Default <c>1</c> (classic APIs). Work-order advanced search sets <c>0</c>.
+        /// </summary>
+        public int PageBase { get; set; } = 1;
+
+        public int TotalPages => PageSize <= 0 ? 0 : (int)Math.Ceiling(TotalCount / (double)PageSize);
+
+        public bool HasPrevious => PageBase <= 0 ? Page > 0 : Page > 1;
+
+        public bool HasNext => PageBase <= 0 ? Page + 1 < TotalPages : Page < TotalPages;
     }
 }
diff --git a/SeaHaven.Services/DTOs/LocationDTOs.cs b/SeaHaven.Services/DTOs/LocationDTOs.cs
index 09e41b6..9b518d0 100644
--- a/SeaHaven.Services/DTOs/LocationDTOs.cs
+++ b/SeaHaven.Services/DTOs/LocationDTOs.cs
@@ -36,4 +36,12 @@ namespace SeaHaven.Services.DTOs
         public string? Zipcode { get; set; }
         public int? AccountId { get; set; }
     }
+
+    public class SiteOptionDTO
+    {
+        public int Id { get; set; }
+        public string? Code { get; set; }
+        public string? City { get; set; }
+        public string? State { get; set; }
+    }
 }
diff --git a/SeaHaven.Services/DTOs/WorkOrderBoardDTOs.cs b/SeaHaven.Services/DTOs/WorkOrderBoardDTOs.cs
new file mode 100644
index 0000000..f0b13f9
--- /dev/null
+++ b/SeaHaven.Services/DTOs/WorkOrderBoardDTOs.cs
@@ -0,0 +1,101 @@
+using Data.SeaHavenIndustries.Enums;
+using SeaHaven.Services.Helpers;
+
+namespace SeaHaven.Services.DTOs
+{
+    public class WorkOrderBoardQueryDto
+    {
+        public DateOnly WeekStart { get; set; }
+        public DateOnly? WeekEnd { get; set; }
+        public List<string>? Dispatchers { get; set; }
+        public bool MyWorkOrders { get; set; }
+        public List<WorkOrderType>? Types { get; set; }
+        public string? Search { get; set; }
+    }
+
+    public class WorkOrderBoardCountsDto
+    {
+        public int Returned { get; set; }
+        public int Total { get; set; }
+    }
+
+    public class WorkOrderBoardRowDto
+    {
+        public int Id { get; set; }
+        public string? WoNumber { get; set; }
+        public int RescheduleCount { get; set; }
+        public int CarriedOver { get; set; }
+        public WorkOrderType? WorkOrderType { get; set; }
+        public bool IsPastDue { get; set; }
+        public string? SiteCode { get; set; }
+        public string? LocationName { get; set; }
+        public string? PocName { get; set; }
+        public string? PocPhone { get; set; }
+        public string? PocNotes { get; set; }
+        public LifecycleStatus? LifecycleStatus { get; set; }
+        public string? LifecycleStatusLabel { get; set; }
+        public string? LegacyStatus { get; set; }
+        public string? DispatcherId { get; set; }
+        public string? DispatcherName { get; set; }
+        public string? Initials { get; set; }
+        public string? Color { get; set; }
+        public DateTime? DueDate { get; set; }
+        public DateTime? ScheduledDate { get; set; }
+        public DateOnly? TargetWeek { get; set; }
+        public bool? ScheduleWeekOnly { get; set; }
+        public string? DayGroup { get; set; }
+        public int? VendorId { get; set; }
+        public string? VendorName { get; set; }
+        public string? TechName { get; set; }
+        public string? TechPhone { get; set; }
+        public DateTime? ApptDate { get; set; }
+        public string? ApptTime { get; set; }
+        public string? Pm { get; set; }
+        public string? ServiceNotes { get; set; }
+        public List<string>? ExtraServices { get; set; }
+        public DocStatus? DocStatus { get; set; }
+        /// <summary>Board flag color (#RRGGBB). Null = no flag. Distinct from Color (dispatcher avatar).</summary>
+        public string? FlagColor { get; set; }
+        public int? PrimaryDispatchId { get; set; }
+        public byte[]? RowVersion { get; set; }
+        public byte[]? DispatchRowVersion { get; set; }
+    }
+
+    public class WorkOrderBoardPatchRequestDto
+    {
+        public string Field { get; set; } = "";
+        public string? Value { get; set; }
+        public string? WorkOrderVersion { get; set; }
+        public string? DispatchVersion { get; set; }
+        public int? PrimaryDispatchId { get; set; }
+    }
+
+    public class WorkOrderBoardConflictDto
+    {
+        public string Message { get; set; } = "The record was modified by another user. Refresh and retry.";
+        public WorkOrderBoardRowDto? CurrentState { get; set; }
+    }
+
+    public class WorkOrderBoardValidationErrorDto
+    {
+        public string Code { get; set; } = "";
+        public string Message { get; set; } = "";
+    }
+
+    public class WorkOrderBoardResponseDto
+    {
+        public DateOnly WeekStart { get; set; }
+        public DateOnly WeekEnd { get; set; }
+        public WorkOrderBoardCountsDto Counts { get; set; } = new();
+        public List<WorkOrderBoardRowDto> Unscheduled { get; set; } = new();
+        public List<WorkOrderBoardRowDto> Scheduled { get; set; } = new();
+    }
+
+    public class DispatcherLookupDto
+    {
+        public string Id { get; set; } = "";
+        public string Name { get; set; } = "";
+        public string? Initials { get; set; }
+        public string? Color { get; set; }
+    }
+}
diff --git a/SeaHaven.Services/DTOs/WorkOrderBoardRequestDTOs.cs b/SeaHaven.Services/DTOs/WorkOrderBoardRequestDTOs.cs
new file mode 100644
index 0000000..b78be76
--- /dev/null
+++ b/SeaHaven.Services/DTOs/WorkOrderBoardRequestDTOs.cs
@@ -0,0 +1,63 @@
+using Data.SeaHavenIndustries.Enums;
+using SeaHaven.Services.Helpers;
+
+namespace SeaHaven.Services.DTOs
+{
+    /// <summary>
+    /// Payload for creating a board work order (SHOC create wizard).
+    /// FE follow-up: extend WorkOrderBoardCreatePayload + mapper with PrimaryService,
+    /// ExtraServices, ServiceNotes, PocName, PocPhone, VendorNotes, TechPhone; stop embedding
+    /// POC/vendor/service notes in description (pocNotes already exists). Prefer structured
+    /// fields; keep Trade+Description temporarily for legacy clients.
+    /// </summary>
+    public class WorkOrderBoardCreateRequestDto
+    {
+        public string? WoNumber { get; set; }
+        public WorkOrderType WorkOrderType { get; set; }
+        public string? SiteCode { get; set; }
+        public string? Description { get; set; }
+        /// <summary>Legacy alias for primary service; prefer <see cref="PrimaryService"/>.</summary>
+        public string? Trade { get; set; }
+        /// <summary>Primary service label; persisted as Trade / board pm.</summary>
+        public string? PrimaryService { get; set; }
+        public List<string>? ExtraServices { get; set; }
+        public string? ServiceNotes { get; set; }
+        public int? LocationId { get; set; }
+        public DateTime? DueDate { get; set; }
+        public string? AssignTo { get; set; }
+        public DateTime? ScheduledDate { get; set; }
+        public DateOnly? TargetWeek { get; set; }
+        public bool? ScheduleWeekOnly { get; set; }
+        public DocStatus? DocStatus { get; set; }
+        public int? VendorId { get; set; }
+        public DateTime? ApptDate { get; set; }
+        public string? ApptTime { get; set; }
+        public int? PocContactId { get; set; }
+        public string? PocName { get; set; }
+        public string? PocPhone { get; set; }
+        public string? PocNotes { get; set; }
+        public string? TechPhone { get; set; }
+        public string? VendorNotes { get; set; }
+    }
+
+    /// <summary>Advanced search / filter query for the board.</summary>
+    public class WorkOrderAdvancedSearchQueryDto
+    {
+        public int Page { get; set; } = 0;
+        public int PageSize { get; set; } = 100;
+        public string? Search { get; set; }
+        public WorkOrderAdvancedSearchDatePreset? DatePreset { get; set; }
+        public DateOnly? DateFrom { get; set; }
+        public DateOnly? DateTo { get; set; }
+        public List<string>? Sites { get; set; }
+        public List<WorkOrderType>? Types { get; set; }
+        public List<string>? Dispatchers { get; set; }
+        public List<LifecycleStatus>? Statuses { get; set; }
+        public List<string>? PmTypes { get; set; }
+        public List<int>? VendorIds { get; set; }
+        public List<DocStatus>? DocStatuses { get; set; }
+        public bool MyWorkOrders { get; set; }
+        public string? SortBy { get; set; }
+        public string? SortDir { get; set; }
+    }
+}
diff --git a/SeaHaven.Services/DTOs/WorkOrderDetailDTOs.cs b/SeaHaven.Services/DTOs/WorkOrderDetailDTOs.cs
new file mode 100644
index 0000000..105e112
--- /dev/null
+++ b/SeaHaven.Services/DTOs/WorkOrderDetailDTOs.cs
@@ -0,0 +1,106 @@
+using Data.SeaHavenIndustries.Enums;
+
+namespace SeaHaven.Services.DTOs
+{
+    public class WorkOrderDetailDto
+    {
+        public WorkOrderDetailInfoDto Info { get; set; } = new();
+        public WorkOrderCompletionDto Completion { get; set; } = new();
+        public List<WorkOrderCommentDto> Comments { get; set; } = new();
+        public List<WorkOrderAuditEntryDto> Audit { get; set; } = new();
+        public List<WorkOrderMediaFileDto> Media { get; set; } = new();
+    }
+
+    public class WorkOrderDetailInfoDto : WorkOrderBoardRowDto
+    {
+        public string? Description { get; set; }
+        public string? Trade { get; set; }
+        public string? Problem { get; set; }
+        public string? SubTrade { get; set; }
+        public DateOnly? OriginalWeek { get; set; }
+        public DateOnly? OriginalDate { get; set; }
+        public DateTime? CompletedDate { get; set; }
+        public string? VendorNotes { get; set; }
+    }
+
+    public class CompletionDocTemplateDto
+    {
+        public int Id { get; set; }
+        public string Name { get; set; } = "";
+        public string ServiceKey { get; set; } = "";
+        public WorkOrderType? WorkOrderType { get; set; }
+        public string TemplateUrl { get; set; } = "";
+        public bool IsActive { get; set; }
+    }
+
+    public class CompletionDocTemplateCreateDto
+    {
+        public string Name { get; set; } = "";
+        public string ServiceKey { get; set; } = "";
+        public WorkOrderType? WorkOrderType { get; set; }
+        public string TemplateUrl { get; set; } = "";
+        public bool IsActive { get; set; } = true;
+    }
+
+    public class WorkOrderCompletionDto
+    {
+        public DocStatus? DocStatus { get; set; }
+        public CompletionDocTemplateDto? Template { get; set; }
+        public string? SignOffName { get; set; }
+        public string? SignOffAttachment { get; set; }
+        public string? SignOffSignature { get; set; }
+        public List<DispatchSignoffDto> DispatchSignoffs { get; set; } = new();
+    }
+
+    public class DispatchSignoffDto
+    {
+        public int DispatchId { get; set; }
+        public string? SignoffType { get; set; }
+        public string? Name { get; set; }
+        public string? SignedAt { get; set; }
+    }
+
+    public class WorkOrderCommentDto
+    {
+        public int Id { get; set; }
+        public string? AuthorId { get; set; }
+        public string? AuthorName { get; set; }
+        public string Text { get; set; } = "";
+        public string Time { get; set; } = "";
+        public string? Documents { get; set; }
+    }
+
+    public class WorkOrderCommentCreateDto
+    {
+        public string Text { get; set; } = "";
+    }
+
+    public class WorkOrderAuditEntryDto
+    {
+        public string Type { get; set; } = "manual";
+        public string? DispatcherId { get; set; }
+        public string Action { get; set; } = "";
+        public string? FieldName { get; set; }
+        public string OldValue { get; set; } = "";
+        public string NewValue { get; set; } = "";
+        public string Time { get; set; } = "";
+        public int? DispatchId { get; set; }
+    }
+
+    public class WorkOrderMediaFileDto
+    {
+        public int Id { get; set; }
+        public WorkOrderMediaCategory Category { get; set; }
+        public string Url { get; set; } = "";
+        public string? FileName { get; set; }
+        public string? UploadedAt { get; set; }
+        public bool IsLegacy { get; set; }
+    }
+
+    public class WorkOrderCompletionDocUploadDto
+    {
+        public string? SignOffName { get; set; }
+        public string? SignOffSignature { get; set; }
+        public string? WorkOrderVersion { get; set; }
+    }
+}
diff --git a/SeaHaven.Services/DTOs/WorkOrderJobDTOs.cs b/SeaHaven.Services/DTOs/WorkOrderJobDTOs.cs
new file mode 100644
index 0000000..885c363
--- /dev/null
+++ b/SeaHaven.Services/DTOs/WorkOrderJobDTOs.cs
@@ -0,0 +1,21 @@
+namespace SeaHaven.Services.DTOs
+{
+    public sealed class WeekRolledJobResult
+    {
+        public int Processed { get; set; }
+        public int Skipped { get; set; }
+        public int Failed { get; set; }
+        public string CorrelationId { get; set; } = "";
+        public DateOnly SourceWeekStart { get; set; }
+        public DateOnly SourceWeekEnd { get; set; }
+        public long DurationMs { get; set; }
+    }
+
+    public sealed class PastDueCacheJobResult
+    {
+        public int SetCount { get; set; }
+        public int ClearedCount { get; set; }
+        public int ExaminedCount { get; set; }
+        public long DurationMs { get; set; }
+    }
+}
diff --git a/SeaHaven.Services/DTOs/WorkOrderPhase7DTOs.cs b/SeaHaven.Services/DTOs/WorkOrderPhase7DTOs.cs
new file mode 100644
index 0000000..4f1087a
--- /dev/null
+++ b/SeaHaven.Services/DTOs/WorkOrderPhase7DTOs.cs
@@ -0,0 +1,54 @@
+namespace SeaHaven.Services.DTOs
+{
+    public sealed class WorkOrderIngestPayloadDto
+    {
+        public required string ExternalWorkOrderId { get; set; }
+        public string? Description { get; set; }
+        public string? WoStatus { get; set; }
+        public string? Severity { get; set; }
+        public string? Customer { get; set; }
+        public string? SiteCode { get; set; }
+        public string? Building { get; set; }
+        public string? Address { get; set; }
+        public DateTime? DueDate { get; set; }
+        public DateTime? DateReported { get; set; }
+        public DateTime? ScheduledStart { get; set; }
+        public string? SourceEmailS3Key { get; set; }
+        public DateTime? CreatedAt { get; set; }
+    }
+
+    public sealed class WorkOrderIngestBatchRequestDto
+    {
+        public List<WorkOrderIngestPayloadDto>? Items { get; set; }
+    }
+
+    public sealed class WorkOrderIngestItemResultDto
+    {
+        public required string ExternalWorkOrderId { get; set; }
+        public int WorkOrderId { get; set; }
+        public bool Created { get; set; }
+    }
+
+    public sealed class WorkOrderIngestBatchResultDto
+    {
+        public int Created { get; set; }
+        public int Updated { get; set; }
+        public int Skipped { get; set; }
+        public List<WorkOrderIngestItemResultDto> Results { get; set; } = new();
+    }
+
+    public sealed class WorkOrderOpsHealthDto
+    {
+        public DateTime? LastWeekRolledRunUtc { get; set; }
+        public DateTime? LastPastDueCacheRunUtc { get; set; }
+        public string? LastWeekRolledError { get; set; }
+        public string? LastPastDueCacheError { get; set; }
+        public int SyncRejectedLast24h { get; set; }
+        public int FieldLockCount { get; set; }
+        public bool SyncEnabled { get; set; }
+        public bool IngestEnabled { get; set; }
+        public bool LegacyDeprecationEnabled { get; set; }
+        public string? LegacySunsetDate { get; set; }
+        public DateTime CheckedAtUtc { get; set; }
+    }
+}
diff --git a/SeaHaven.Services/Exceptions/WorkOrderBoardExceptions.cs b/SeaHaven.Services/Exceptions/WorkOrderBoardExceptions.cs
new file mode 100644
index 0000000..c15ecd0
--- /dev/null
+++ b/SeaHaven.Services/Exceptions/WorkOrderBoardExceptions.cs
@@ -0,0 +1,25 @@
+using SeaHaven.Services.DTOs;
+
+namespace SeaHaven.Services.Exceptions
+{
+    public class WorkOrderBoardValidationException : Exception
+    {
+        public WorkOrderBoardValidationException(string code, string message) : base(message)
+        {
+            Code = code;
+        }
+
+        public string Code { get; }
+    }
+
+    public class WorkOrderBoardConcurrencyException : Exception
+    {
+        public WorkOrderBoardConcurrencyException(WorkOrderBoardRowDto? currentState)
+            : base("The record was modified by another user. Refresh and retry.")
+        {
+            CurrentState = currentState;
+        }
+
+        public WorkOrderBoardRowDto? CurrentState { get; }
+    }
+}
diff --git a/SeaHaven.Services/Helpers/LifecycleStatusMapper.cs b/SeaHaven.Services/Helpers/LifecycleStatusMapper.cs
new file mode 100644
index 0000000..551fa66
--- /dev/null
+++ b/SeaHaven.Services/Helpers/LifecycleStatusMapper.cs
@@ -0,0 +1,85 @@
+using Data.SeaHavenIndustries.Enums;
+
+namespace SeaHaven.Services.Helpers
+{
+    public static class LifecycleStatusMapper
+    {
+        public static LifecycleStatus? FromLegacyStatus(string? status)
+        {
+            if (string.IsNullOrWhiteSpace(status)) return null;
+
+            return status.Trim().ToLowerInvariant() switch
+            {
+                "open" or "incomplete" => LifecycleStatus.Incomplete,
+                "pending" or "onhold" or "on hold" => LifecycleStatus.Pending,
+                "scheduled" => LifecycleStatus.Scheduled,
+                "en route" or "enroute" => LifecycleStatus.EnRoute,
+                "on site" or "onsite" => LifecycleStatus.OnSite,
+                "inprogress" or "in progress" => LifecycleStatus.InProgress,
+                "completed" or "complete" or "done" or "closed" => LifecycleStatus.Completed,
+                "rescheduled" => LifecycleStatus.Rescheduled,
+                "cancelled" or "canceled" => LifecycleStatus.Canceled,
+                "pending quote" or "pendingquote" or "pendingapproval" or "pending approval" => LifecycleStatus.PendingQuote,
+                _ => null
+            };
+        }
+
+        public static LifecycleStatus? ParseLifecycleStatus(string? value)
+        {
+            if (string.IsNullOrWhiteSpace(value)) return null;
+
+            if (TryParseFeLabel(value, out var fromLabel))
+                return fromLabel;
+
+            if (Enum.TryParse<LifecycleStatus>(value, true, out var parsed))
+                return parsed;
+
+            return FromLegacyStatus(value);
+        }
+
+        public static bool TryParseFeLabel(string? label, out LifecycleStatus status)
+        {
+            status = default;
+            if (string.IsNullOrWhiteSpace(label)) return false;
+
+            return label.Trim().ToLowerInvariant() switch
+            {
+                "incomplete" => Set(LifecycleStatus.Incomplete, out status),
+                "pending" => Set(LifecycleStatus.Pending, out status),
+                "scheduled" => Set(LifecycleStatus.Scheduled, out status),
+                "en route" => Set(LifecycleStatus.EnRoute, out status),
+                "on site" => Set(LifecycleStatus.OnSite, out status),
+                "in progress" => Set(LifecycleStatus.InProgress, out status),
+                "completed" => Set(LifecycleStatus.Completed, out status),
+                "rescheduled" => Set(LifecycleStatus.Rescheduled, out status),
+                "canceled" => Set(LifecycleStatus.Canceled, out status),
+                "pending quote" => Set(LifecycleStatus.PendingQuote, out status),
+                _ => false
+            };
+        }
+
+        public static string ToFeLabel(LifecycleStatus status) => status switch
+        {
+            LifecycleStatus.Incomplete => "Incomplete",
+            LifecycleStatus.Pending => "Pending",
+            LifecycleStatus.Scheduled => "Scheduled",
+            LifecycleStatus.EnRoute => "En Route",
+            LifecycleStatus.OnSite => "On Site",
+            LifecycleStatus.InProgress => "In Progress",
+            LifecycleStatus.Completed => "Completed",
+            LifecycleStatus.Rescheduled => "Rescheduled",
+            LifecycleStatus.Canceled => "Canceled",
+            LifecycleStatus.PendingQuote => "Pending Quote",
+            _ => status.ToString()
+        };
+
+        public static bool IsTerminal(LifecycleStatus? status)
+            => status is LifecycleStatus.Completed or LifecycleStatus.Canceled;
+
+        private static bool Set(LifecycleStatus value, out LifecycleStatus status)
+        {
+            status = value;
+            return true;
+        }
+    }
+}
diff --git a/SeaHaven.Services/Helpers/WorkOrderAuditProjection.cs b/SeaHaven.Services/Helpers/WorkOrderAuditProjection.cs
new file mode 100644
index 0000000..6a7e295
--- /dev/null
+++ b/SeaHaven.Services/Helpers/WorkOrderAuditProjection.cs
@@ -0,0 +1,87 @@
+using Data.SeaHavenIndustries;
+using SeaHaven.Services.DTOs;
+
+namespace SeaHaven.Services.Helpers
+{
+    public static class WorkOrderAuditProjection
+    {
+        private const string UnassignedLabel = "Unassigned";
+
+        public static WorkOrderAuditEntryDto ToDto(
+            WorkOrderAuditLog log,
+            IReadOnlyDictionary<string, string>? assignToDisplayNames = null)
+        {
+            var oldValue = log.OldValue ?? "";
+            var newValue = log.NewValue ?? "";
+
+            if (IsAssignToField(log.FieldName))
+            {
+                oldValue = ResolveAssignToDisplay(oldValue, assignToDisplayNames);
+                newValue = ResolveAssignToDisplay(newValue, assignToDisplayNames);
+            }
+
+            return new WorkOrderAuditEntryDto
+            {
+                Type = MapEventType(log.EventType),
+                DispatcherId = log.UserId,
+                Action = log.Action ?? "",
+                FieldName = log.FieldName,
+                OldValue = oldValue,
+                NewValue = newValue,
+                Time = log.CreatedAt.ToString("o"),
+                DispatchId = log.DispatchId
+            };
+        }
+
+        public static List<WorkOrderAuditEntryDto> ToDtos(
+            IEnumerable<WorkOrderAuditLog> logs,
+            IReadOnlyDictionary<string, string>? assignToDisplayNames = null)
+            => logs.Select(log => ToDto(log, assignToDisplayNames)).ToList();
+
+        public static IEnumerable<string> CollectAssignToUserIds(IEnumerable<WorkOrderAuditLog> logs)
+        {
+            return logs
+                .Where(l => IsAssignToField(l.FieldName))
+                .SelectMany(l => new[] { l.OldValue, l.NewValue })
+                .Where(v => !string.IsNullOrWhiteSpace(v))
+                .Select(v => v!)
+                .Distinct(StringComparer.Ordinal);
+        }
+
+        internal static bool IsAssignToField(string? fieldName)
+            => string.Equals(fieldName, "AssignTo", StringComparison.OrdinalIgnoreCase)
+               || string.Equals(fieldName, "AssignedTo", StringComparison.OrdinalIgnoreCase);
+
+        private static string ResolveAssignToDisplay(
+            string value,
+            IReadOnlyDictionary<string, string>? assignToDisplayNames)
+        {
+            if (string.IsNullOrWhiteSpace(value))
+                return UnassignedLabel;
+
+            if (assignToDisplayNames != null
+                && assignToDisplayNames.TryGetValue(value, out var name)
+                && !string.IsNullOrWhiteSpace(name))
+            {
+                return name;
+            }
+
+            return value;
+        }
+
+        private static string MapEventType(string? eventType)
+        {
+            if (string.IsNullOrWhiteSpace(eventType))
+                return "manual";
+
+            return eventType.ToLowerInvariant() switch
+            {
+                "manual" => "manual",
+                "system" => "system",
+                "sync" => "sync",
+                "vendor" => "vendor",
+                _ => eventType.ToLowerInvariant()
+            };
+        }
+    }
+}
diff --git a/SeaHaven.Services/Helpers/WorkOrderBoardApptTimeParser.cs b/SeaHaven.Services/Helpers/WorkOrderBoardApptTimeParser.cs
new file mode 100644
index 0000000..f50949a
--- /dev/null
+++ b/SeaHaven.Services/Helpers/WorkOrderBoardApptTimeParser.cs
@@ -0,0 +1,57 @@
+namespace SeaHaven.Services.Helpers
+{
+    public static class WorkOrderBoardApptTimeParser
+    {
+        public static bool TryParse(string? value, out TimeSpan? start, out TimeSpan? end, out string? error)
+        {
+            start = null;
+            end = null;
+            error = null;
+
+            if (string.IsNullOrWhiteSpace(value))
+                return true;
+
+            var trimmed = value.Trim();
+            var parts = trimmed.Split(new[] { '–', '—', '-' })
+                .Select(p => p.Trim())
+                .Where(p => !string.IsNullOrEmpty(p))
+                .ToArray();
+
+            if (parts.Length == 1)
+            {
+                if (!TimeSpan.TryParse(parts[0], out var single))
+                {
+                    error = "Invalid appointment time format.";
+                    return false;
+                }
+
+                start = single;
+                return true;
+            }
+
+            if (parts.Length == 2)
+            {
+                if (!TimeSpan.TryParse(parts[0], out var startTime) || !TimeSpan.TryParse(parts[1], out var endTime))
+                {
+                    error = "Invalid appointment time range format.";
+                    return false;
+                }
+
+                start = startTime;
+                end = endTime;
+                return true;
+            }
+
+            error = "Invalid appointment time format.";
+            return false;
+        }
+
+        public static DateTime? CombineDateAndTime(DateTime? date, TimeSpan? time)
+        {
+            if (!date.HasValue || !time.HasValue)
+                return date;
+
+            return date.Value.Date.Add(time.Value);
+        }
+    }
+}
diff --git a/SeaHaven.Services/Helpers/WorkOrderBoardFieldMutations.cs b/SeaHaven.Services/Helpers/WorkOrderBoardFieldMutations.cs
new file mode 100644
index 0000000..b0bf837
--- /dev/null
+++ b/SeaHaven.Services/Helpers/WorkOrderBoardFieldMutations.cs
@@ -0,0 +1,132 @@
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+using SeaHaven.Services.Exceptions;
+
+namespace SeaHaven.Services.Helpers
+{
+    public static class WorkOrderBoardFieldMutations
+    {
+        public static List<BoardFieldChange> ApplyAssignTo(WorkOrder workOrder, string? value, string auditField = "AssignTo")
+        {
+            var normalized = string.IsNullOrWhiteSpace(value) ? null : value.Trim();
+            var old = workOrder.AssignTo;
+            var changes = new List<BoardFieldChange>();
+
+            if (old != normalized)
+            {
+                workOrder.AssignTo = normalized;
+                changes.Add(BoardFieldChange.AssignmentChanged(auditField, old, normalized));
+            }
+
+            changes.AddRange(ApplyAutoScheduleSideEffects(workOrder));
+            return changes;
+        }
+
+        public static List<BoardFieldChange> ApplyScheduledDate(
+            WorkOrder workOrder,
+            DateTime? parsed,
+            string auditField = "ScheduledDate",
+            bool incrementRescheduleOnChange = true)
+        {
+            var previousDate = workOrder.ScheduledDate;
+            var changes = new List<BoardFieldChange>();
+            var oldFormatted = FormatDate(previousDate);
+            var newFormatted = FormatDate(parsed);
+
+            if (oldFormatted == newFormatted)
+                return changes;
+
+            workOrder.ScheduledDate = parsed;
+            changes.Add(BoardFieldChange.Changed(auditField, oldFormatted, newFormatted));
+
+            if (!workOrder.OriginalDate.HasValue && parsed.HasValue)
+            {
+                workOrder.OriginalDate = DateOnly.FromDateTime(parsed.Value);
+                var originalWeek = WorkOrderBoardMutationRules.ComputeOriginalWeek(parsed);
+                if (originalWeek.HasValue)
+                    workOrder.OriginalWeek = originalWeek;
+            }
+
+            if (incrementRescheduleOnChange && WorkOrderBoardMutationRules.IsReschedule(previousDate, parsed))
+            {
+                var oldCount = workOrder.RescheduleCount.ToString();
+                workOrder.RescheduleCount++;
+                changes.Add(BoardFieldChange.Changed(
+                    WorkOrderBoardFieldNames.RescheduleCount,
+                    oldCount,
+                    workOrder.RescheduleCount.ToString()));
+            }
+
+            changes.AddRange(ApplyAutoScheduleSideEffects(workOrder));
+            return changes;
+        }
+
+        public static List<BoardFieldChange> ApplyAutoScheduleSideEffects(WorkOrder workOrder)
+        {
+            var changes = new List<BoardFieldChange>();
+            if (!WorkOrderBoardMutationRules.ShouldAutoSchedule(workOrder.LifecycleStatus, workOrder.ScheduledDate, workOrder.AssignTo))
+                return changes;
+
+            var old = workOrder.LifecycleStatus?.ToString();
+            workOrder.LifecycleStatus = LifecycleStatus.Scheduled;
+            workOrder.Status = WorkOrderDerivedFields.GetLifecycleStatusLabel(LifecycleStatus.Scheduled);
+            changes.Add(BoardFieldChange.StatusChanged("LifecycleStatus", old, LifecycleStatus.Scheduled.ToString()));
+            return changes;
+        }
+
+        public static BoardFieldChange ApplyApptTime(WorkOrder workOrder, Dispatch dispatch, string? value)
+        {
+            if (!WorkOrderBoardApptTimeParser.TryParse(value, out var start, out var end, out var error))
+                throw new WorkOrderBoardValidationException("InvalidValue", error ?? "Invalid apptTime.");
+
+            var apptDate = dispatch.ScheduledDate ?? workOrder.ScheduledDate;
+            var oldStart = FormatDateTime(workOrder.ScheduledStart);
+            var oldEnd = FormatDateTime(workOrder.ScheduledEnd);
+
+            workOrder.ScheduledStart = WorkOrderBoardApptTimeParser.CombineDateAndTime(apptDate, start);
+            workOrder.ScheduledEnd = WorkOrderBoardApptTimeParser.CombineDateAndTime(apptDate, end);
+
+            var newStart = FormatDateTime(workOrder.ScheduledStart);
+            var newEnd = FormatDateTime(workOrder.ScheduledEnd);
+            var oldCombined = FormatApptRange(oldStart, oldEnd);
+            var newCombined = FormatApptRange(newStart, newEnd);
+
+            if (oldCombined == newCombined)
+                return BoardFieldChange.Unchanged("ApptTime", dispatch.Id);
+
+            return BoardFieldChange.Changed("ApptTime", oldCombined, newCombined, dispatch.Id);
+        }
+
+        public static void SetInitialLifecycleStatus(WorkOrder workOrder)
+        {
+            workOrder.LifecycleStatus = LifecycleStatus.Incomplete;
+            workOrder.Status = WorkOrderDerivedFields.GetLifecycleStatusLabel(LifecycleStatus.Incomplete);
+        }
+
+        private static string? FormatDate(DateTime? value) => value?.ToString("yyyy-MM-dd");
+        private static string? FormatDateTime(DateTime? value) => value?.ToString("O");
+        private static string? FormatApptRange(string? start, string? end)
+            => start == null && end == null ? null : $"{start}|{end}";
+
+        public sealed record BoardFieldChange(
+            string FieldName,
+            string? OldValue,
+            string? NewValue,
+            AuditActionType Action,
+            int? DispatchId,
+            bool HasChanged)
+        {
+            public static BoardFieldChange Unchanged(string fieldName, int? dispatchId = null)
+                => new(fieldName, null, null, AuditActionType.FieldChanged, dispatchId, false);
+
+            public static BoardFieldChange Changed(string fieldName, string? oldValue, string? newValue, int? dispatchId = null)
+                => new(fieldName, oldValue, newValue, AuditActionType.FieldChanged, dispatchId, true);
+
+            public static BoardFieldChange StatusChanged(string fieldName, string? oldValue, string? newValue)
+                => new(fieldName, oldValue, newValue, AuditActionType.StatusChanged, null, true);
+
+            public static BoardFieldChange AssignmentChanged(string fieldName, string? oldValue, string? newValue)
+                => new(fieldName, oldValue, newValue, AuditActionType.AssignmentChanged, null, true);
+        }
+    }
+}
diff --git a/SeaHaven.Services/Helpers/WorkOrderBoardFieldNames.cs b/SeaHaven.Services/Helpers/WorkOrderBoardFieldNames.cs
new file mode 100644
index 0000000..a76a7fe
--- /dev/null
+++ b/SeaHaven.Services/Helpers/WorkOrderBoardFieldNames.cs
@@ -0,0 +1,94 @@
+namespace SeaHaven.Services.Helpers
+{
+    public static class WorkOrderBoardFieldNames
+    {
+        public const string WoNumber = "woNumber";
+        public const string WorkOrderType = "workOrderType";
+        public const string SiteCode = "siteCode";
+        public const string LifecycleStatus = "lifecycleStatus";
+        public const string AssignTo = "assignTo";
+        public const string DueDate = "dueDate";
+        public const string ScheduledDate = "scheduledDate";
+        public const string TargetWeek = "targetWeek";
+        public const string ScheduleWeekOnly = "scheduleWeekOnly";
+        public const string VendorId = "vendorId";
+        public const string ApptDate = "apptDate";
+        public const string ApptTime = "apptTime";
+        public const string DocStatus = "docStatus";
+        public const string Pm = "pm";
+        public const string ServiceNotes = "serviceNotes";
+        public const string ExtraServices = "extraServices";
+        public const string FlagColor = "flagColor";
+        public const string RescheduleCount = "RescheduleCount";
+
+        private static readonly HashSet<string> DispatchFields = new(StringComparer.OrdinalIgnoreCase)
+        {
+            VendorId,
+            ApptDate,
+            ApptTime
+        };
+
+        private static readonly HashSet<string> AllEditable = new(StringComparer.OrdinalIgnoreCase)
+        {
+            WoNumber,
+            WorkOrderType,
+            SiteCode,
+            LifecycleStatus,
+            AssignTo,
+            DueDate,
+            ScheduledDate,
+            TargetWeek,
+            ScheduleWeekOnly,
+            VendorId,
+            ApptDate,
+            ApptTime,
+            DocStatus,
+            Pm,
+            ServiceNotes,
+            ExtraServices,
+            FlagColor
+        };
+
+        public static bool IsEditable(string field) => Canonicalize(field) != null;
+
+        public static bool IsDispatchField(string field)
+        {
+            var canonical = Canonicalize(field);
+            return canonical != null && DispatchFields.Contains(canonical);
+        }
+
+        public static string? Canonicalize(string field)
+        {
+            if (string.IsNullOrWhiteSpace(field))
+                return null;
+
+            return AllEditable.FirstOrDefault(f => string.Equals(f, field, StringComparison.OrdinalIgnoreCase));
+        }
+
+        public static string ToAuditFieldName(string field)
+        {
+            var canonical = Canonicalize(field) ?? field;
+            return canonical switch
+        {
+            WoNumber => "InternalWONumber",
+            WorkOrderType => "WorkOrderType",
+            SiteCode => "SiteCode",
+            LifecycleStatus => "LifecycleStatus",
+            AssignTo => "AssignTo",
+            DueDate => "DueDate",
+            ScheduledDate => "ScheduledDate",
+            TargetWeek => "TargetWeek",
+            ScheduleWeekOnly => "ScheduleWeekOnly",
+            VendorId => "VendorId",
+            ApptDate => "ApptDate",
+            ApptTime => "ApptTime",
+            DocStatus => "DocStatus",
+            Pm => "Trade",
+            ServiceNotes => "ServiceNotes",
+            ExtraServices => "ExtraServices",
+            FlagColor => "FlagColor",
+            _ => canonical
+        };
+        }
+    }
+}
diff --git a/SeaHaven.Services/Helpers/WorkOrderBoardMutationRules.cs b/SeaHaven.Services/Helpers/WorkOrderBoardMutationRules.cs
new file mode 100644
index 0000000..0f2be7e
--- /dev/null
+++ b/SeaHaven.Services/Helpers/WorkOrderBoardMutationRules.cs
@@ -0,0 +1,42 @@
+using Data.SeaHavenIndustries.Enums;
+
+namespace SeaHaven.Services.Helpers
+{
+    public static class WorkOrderBoardMutationRules
+    {
+        private static readonly HashSet<LifecycleStatus?> ReadOnlyStatuses = new()
+        {
+            LifecycleStatus.Canceled,
+            LifecycleStatus.Completed
+        };
+
+        public static bool IsReadOnly(LifecycleStatus? status) => ReadOnlyStatuses.Contains(status);
+
+        public static bool ShouldBlockStatusChangeWhenPastDue(string field, bool isPastDue)
+            => field.Equals(WorkOrderBoardFieldNames.LifecycleStatus, StringComparison.OrdinalIgnoreCase) && isPastDue;
+
+        public static bool ShouldAutoSchedule(
+            LifecycleStatus? status,
+            DateTime? scheduledDate,
+            string? assignTo)
+            => status == LifecycleStatus.Incomplete
+               && scheduledDate.HasValue
+               && !string.IsNullOrWhiteSpace(assignTo);
+
+        public static bool IsReschedule(DateTime? previousDate, DateTime? newDate)
+            => previousDate.HasValue
+               && newDate.HasValue
+               && previousDate.Value.Date != newDate.Value.Date;
+
+        public static DateOnly? ComputeOriginalWeek(DateTime? scheduledDate)
+            => scheduledDate.HasValue
+                ? DateOnly.FromDateTime(GetWeekStartMonday(scheduledDate.Value))
+                : null;
+
+        private static DateTime GetWeekStartMonday(DateTime date)
+        {
+            var diff = (7 + (date.DayOfWeek - DayOfWeek.Monday)) % 7;
+            return date.Date.AddDays(-diff);
+        }
+    }
+}
diff --git a/SeaHaven.Services/Helpers/WorkOrderBoardSortFields.cs b/SeaHaven.Services/Helpers/WorkOrderBoardSortFields.cs
new file mode 100644
index 0000000..e2505a3
--- /dev/null
+++ b/SeaHaven.Services/Helpers/WorkOrderBoardSortFields.cs
@@ -0,0 +1,29 @@
+namespace SeaHaven.Services.Helpers
+{
+    public static class WorkOrderBoardSortFields
+    {
+        public static readonly IReadOnlySet<string> Allowed = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+        {
+            "scheduledDate",
+            "woNumber",
+            "dueDate"
+        };
+
+        public static string NormalizeOrThrow(string? sortBy)
+        {
+            var field = (sortBy ?? "scheduledDate").Trim();
+            if (!Allowed.Contains(field))
+            {
+                throw new ArgumentException(
+                    "sortBy must be one of: scheduledDate, woNumber, dueDate.");
+            }
+
+            return field.ToLowerInvariant() switch
+            {
+                "wonumber" => "woNumber",
+                "duedate" => "dueDate",
+                _ => "scheduledDate"
+            };
+        }
+    }
+}
diff --git a/SeaHaven.Services/Helpers/WorkOrderCommentProjection.cs b/SeaHaven.Services/Helpers/WorkOrderCommentProjection.cs
new file mode 100644
index 0000000..cb4a2d5
--- /dev/null
+++ b/SeaHaven.Services/Helpers/WorkOrderCommentProjection.cs
@@ -0,0 +1,52 @@
+using Data.SeaHavenIndustries;
+using SeaHaven.Services.DTOs;
+
+namespace SeaHaven.Services.Helpers
+{
+    public static class WorkOrderCommentProjection
+    {
+        public static WorkOrderCommentDto ToDto(
+            Comments comment,
+            IReadOnlyDictionary<string, string>? displayNames = null)
+        {
+            return new WorkOrderCommentDto
+            {
+                Id = comment.Id,
+                AuthorId = comment.UserId,
+                AuthorName = ResolveAuthorName(comment, displayNames),
+                Text = comment.Commenttext ?? "",
+                Time = (comment.CreatedDate ?? DateTime.UtcNow).ToUniversalTime().ToString("o"),
+                Documents = comment.Documents
+            };
+        }
+
+        public static List<WorkOrderCommentDto> ToDtos(
+            IEnumerable<Comments> comments,
+            IReadOnlyDictionary<string, string>? displayNames = null)
+            => comments.Select(c => ToDto(c, displayNames)).ToList();
+
+        public static IEnumerable<string> CollectAuthorUserIds(IEnumerable<Comments> comments)
+            => comments
+                .Where(c => !string.IsNullOrWhiteSpace(c.UserId))
+                .Select(c => c.UserId!)
+                .Distinct(StringComparer.Ordinal);
+
+        private static string? ResolveAuthorName(
+            Comments comment,
+            IReadOnlyDictionary<string, string>? displayNames)
+        {
+            if (!string.IsNullOrWhiteSpace(comment.UserId)
+                && displayNames != null
+                && displayNames.TryGetValue(comment.UserId, out var name)
+                && !string.IsNullOrWhiteSpace(name))
+            {
+                return name;
+            }
+
+            if (!string.IsNullOrWhiteSpace(comment.Commenter))
+                return comment.Commenter.Trim();
+
+            return null;
+        }
+    }
+}
diff --git a/SeaHaven.Services/Helpers/WorkOrderDerivedFields.cs b/SeaHaven.Services/Helpers/WorkOrderDerivedFields.cs
new file mode 100644
index 0000000..cb64549
--- /dev/null
+++ b/SeaHaven.Services/Helpers/WorkOrderDerivedFields.cs
@@ -0,0 +1,99 @@
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+
+namespace SeaHaven.Services.Helpers
+{
+    public static class WorkOrderDerivedFields
+    {
+        /// <summary>
+        /// Past due overlay — never a WorkOrderType. Matches SHOC board design.
+        /// </summary>
+        public static bool IsPastDue(WorkOrder workOrder, DateOnly? asOf = null)
+        {
+            var today = asOf ?? DateOnly.FromDateTime(DateTime.UtcNow);
+            if (workOrder.ScheduledDate == null)
+                return false;
+
+            if (LifecycleStatusMapper.IsTerminal(workOrder.LifecycleStatus))
+                return false;
+
+            return DateOnly.FromDateTime(workOrder.ScheduledDate.Value.Date) < today;
+        }
+
+        public static bool IsPastDue(
+            DateTime? scheduledDate,
+            LifecycleStatus? lifecycleStatus,
+            DateTime? utcNow = null)
+        {
+            if (!scheduledDate.HasValue)
+                return false;
+
+            if (LifecycleStatusMapper.IsTerminal(lifecycleStatus))
+                return false;
+
+            var today = (utcNow ?? DateTime.UtcNow).Date;
+            return scheduledDate.Value.Date < today;
+        }
+
+        /// <summary>
+        /// Sets initial lifecycle on create. New WOs start Incomplete unless auto-scheduled.
+        /// </summary>
+        public static void SetInitialLifecycleStatus(WorkOrder workOrder)
+        {
+            workOrder.LifecycleStatus ??= LifecycleStatus.Incomplete;
+            ApplyAutoScheduleIfEligible(workOrder);
+        }
+
+        /// <summary>
+        /// SHOC rule: specific scheduled date + assignee + Incomplete → Scheduled.
+        /// Week-only targets do not auto-schedule.
+        /// </summary>
+        public static bool ApplyAutoScheduleIfEligible(WorkOrder workOrder)
+        {
+            if (workOrder.LifecycleStatus != LifecycleStatus.Incomplete)
+                return false;
+
+            if (workOrder.ScheduleWeekOnly == true)
+                return false;
+
+            if (workOrder.ScheduledDate == null)
+                return false;
+
+            if (string.IsNullOrWhiteSpace(workOrder.AssignTo))
+                return false;
+
+            workOrder.LifecycleStatus = LifecycleStatus.Scheduled;
+            return true;
+        }
+
+        public static string? GetDayGroup(DateTime? scheduledDate)
+        {
+            if (!scheduledDate.HasValue)
+                return null;
+
+            return scheduledDate.Value.DayOfWeek switch
+            {
+                DayOfWeek.Monday => "monday",
+                DayOfWeek.Tuesday => "tuesday",
+                DayOfWeek.Wednesday => "wednesday",
+                DayOfWeek.Thursday => "thursday",
+                DayOfWeek.Friday => "friday",
+                _ => null
+            };
+        }
+
+        public static string? FormatApptTime(DateTime? start, DateTime? end)
+        {
+            if (!start.HasValue)
+                return null;
+
+            if (end.HasValue)
+                return $"{start.Value:HH:mm} – {end.Value:HH:mm}";
+
+            return start.Value.ToString("HH:mm");
+        }
+
+        public static string GetLifecycleStatusLabel(LifecycleStatus? status)
+            => status.HasValue ? LifecycleStatusMapper.ToFeLabel(status.Value) : "";
+    }
+}
diff --git a/SeaHaven.Services/Helpers/WorkOrderFlagColors.cs b/SeaHaven.Services/Helpers/WorkOrderFlagColors.cs
new file mode 100644
index 0000000..6892bd8
--- /dev/null
+++ b/SeaHaven.Services/Helpers/WorkOrderFlagColors.cs
@@ -0,0 +1,50 @@
+namespace SeaHaven.Services.Helpers
+{
+    /// <summary>
+    /// Fixed board flag palette (must match FE FLAG_COLORS). Values stored as canonical #RRGGBB.
+    /// </summary>
+    public static class WorkOrderFlagColors
+    {
+        public static readonly HashSet<string> Allowed = new(StringComparer.OrdinalIgnoreCase)
+        {
+            "#EF4444",
+            "#F97316",
+            "#F59E0B",
+            "#EAB308",
+            "#22C55E",
+            "#14B8A6",
+            "#3B82F6",
+            "#8B5CF6"
+        };
+
+        /// <summary>
+        /// Normalizes to # + 6 uppercase hex digits, or null if empty.
+        /// Returns false if the value is non-empty but not a valid hex color.
+        /// </summary>
+        public static bool TryNormalize(string? value, out string? canonical)
+        {
+            canonical = null;
+            if (string.IsNullOrWhiteSpace(value))
+                return true;
+
+            var trimmed = value.Trim();
+            if (trimmed.Length == 6 && trimmed[0] != '#')
+                trimmed = "#" + trimmed;
+
+            if (trimmed.Length != 7 || trimmed[0] != '#')
+                return false;
+
+            for (var i = 1; i < 7; i++)
+            {
+                if (!Char.IsAsciiHexDigit(trimmed[i]))
+                    return false;
+            }
+
+            canonical = "#" + trimmed[1..].ToUpperInvariant();
+            return true;
+        }
+
+        public static bool IsAllowed(string? canonical)
+            => canonical != null && Allowed.Contains(canonical);
+    }
+}
diff --git a/SeaHaven.Services/Helpers/WorkOrderIngestFieldMapper.cs b/SeaHaven.Services/Helpers/WorkOrderIngestFieldMapper.cs
new file mode 100644
index 0000000..cc48e5e
--- /dev/null
+++ b/SeaHaven.Services/Helpers/WorkOrderIngestFieldMapper.cs
@@ -0,0 +1,27 @@
+namespace SeaHaven.Services.Helpers
+{
+    /// <summary>DynamoDB / ingest field mapping shared by Sync and direct ingest.</summary>
+    public static class WorkOrderIngestFieldMapper
+    {
+        public static string? MapStatus(string? dynamoStatus)
+        {
+            return dynamoStatus switch
+            {
+                "new" => "Open",
+                "assigned" => "Open",
+                "in_progress" => "In Progress",
+                "on_hold" => "On Hold",
+                "completed" => "Done",
+                "cancelled" => "Cancelled",
+                "unknown" => "Open",
+                _ => string.IsNullOrWhiteSpace(dynamoStatus) ? null : "Open"
+            };
+        }
+
+        public static string? MapSeverityToPriority(string? severity)
+        {
+            if (string.IsNullOrWhiteSpace(severity)) return null;
+            return $"Sev {severity}";
+        }
+    }
+}
diff --git a/SeaHaven.Services/Helpers/WorkOrderMediaProjection.cs b/SeaHaven.Services/Helpers/WorkOrderMediaProjection.cs
new file mode 100644
index 0000000..cbacc09
--- /dev/null
+++ b/SeaHaven.Services/Helpers/WorkOrderMediaProjection.cs
@@ -0,0 +1,91 @@
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+using SeaHaven.Services.DTOs;
+
+namespace SeaHaven.Services.Helpers
+{
+    public static class WorkOrderMediaProjection
+    {
+        public static List<WorkOrderMediaFileDto> ProjectAll(
+            WorkOrder workOrder,
+            IEnumerable<WorkOrderAttachments> attachments)
+        {
+            var media = new List<WorkOrderMediaFileDto>();
+            var attachmentId = -1;
+
+            if (!string.IsNullOrWhiteSpace(workOrder.BeforPhotoAttachment))
+            {
+                media.Add(new WorkOrderMediaFileDto
+                {
+                    Id = attachmentId--,
+                    Category = WorkOrderMediaCategory.Before,
+                    Url = workOrder.BeforPhotoAttachment,
+                    FileName = ExtractFileName(workOrder.BeforPhotoAttachment),
+                    IsLegacy = true
+                });
+            }
+
+            if (!string.IsNullOrWhiteSpace(workOrder.AfterPhotoAttachment))
+            {
+                media.Add(new WorkOrderMediaFileDto
+                {
+                    Id = attachmentId--,
+                    Category = WorkOrderMediaCategory.After,
+                    Url = workOrder.AfterPhotoAttachment,
+                    FileName = ExtractFileName(workOrder.AfterPhotoAttachment),
+                    IsLegacy = true
+                });
+            }
+
+            if (!string.IsNullOrWhiteSpace(workOrder.SignOffAttachment))
+            {
+                media.Add(new WorkOrderMediaFileDto
+                {
+                    Id = attachmentId--,
+                    Category = WorkOrderMediaCategory.Completion,
+                    Url = workOrder.SignOffAttachment,
+                    FileName = ExtractFileName(workOrder.SignOffAttachment),
+                    IsLegacy = true
+                });
+            }
+
+            foreach (var attachment in attachments.Where(a => a.IsDeleted != true))
+            {
+                if (string.IsNullOrWhiteSpace(attachment.Attachments))
+                    continue;
+
+                media.Add(new WorkOrderMediaFileDto
+                {
+                    Id = attachment.Id,
+                    Category = attachment.Category ?? WorkOrderMediaCategory.Extra,
+                    Url = attachment.Attachments,
+                    FileName = ExtractFileName(attachment.Attachments),
+                    UploadedAt = attachment.CreatedDate?.ToUniversalTime().ToString("o"),
+                    IsLegacy = false
+                });
+            }
+
+            return media;
+        }
+
+        private static string? ExtractFileName(string url)
+        {
+            if (string.IsNullOrWhiteSpace(url))
+                return null;
+
+            var lastSlash = url.LastIndexOf('/');
+            var segment = lastSlash >= 0 && lastSlash < url.Length - 1
+                ? url[(lastSlash + 1)..]
+                : url;
+
+            try
+            {
+                return Uri.UnescapeDataString(segment);
+            }
+            catch (Exception)
+            {
+                return segment;
+            }
+        }
+    }
+}
diff --git a/SeaHaven.Services/Helpers/WorkOrderNumberNormalizer.cs b/SeaHaven.Services/Helpers/WorkOrderNumberNormalizer.cs
new file mode 100644
index 0000000..59f8494
--- /dev/null
+++ b/SeaHaven.Services/Helpers/WorkOrderNumberNormalizer.cs
@@ -0,0 +1,37 @@
+using System.Text.RegularExpressions;
+
+namespace SeaHaven.Services.Helpers
+{
+    public static class WorkOrderNumberNormalizer
+    {
+        private const int RequiredLength = 11;
+
+        public static bool TryNormalize(string? input, out string normalized, out string? error)
+        {
+            normalized = "";
+            error = null;
+
+            if (string.IsNullOrWhiteSpace(input))
+            {
+                error = "WO number is required.";
+                return false;
+            }
+
+            var digits = Regex.Replace(input.Trim(), @"\D", "");
+            if (digits.Length == 0)
+            {
+                error = "WO number must contain digits.";
+                return false;
+            }
+
+            if (digits.Length > RequiredLength)
+            {
+                error = $"WO number cannot exceed {RequiredLength} digits.";
+                return false;
+            }
+
+            normalized = digits.PadLeft(RequiredLength, '0');
+            return true;
+        }
+    }
+}
diff --git a/SeaHaven.Services/Helpers/WorkOrderOperationalWeek.cs b/SeaHaven.Services/Helpers/WorkOrderOperationalWeek.cs
new file mode 100644
index 0000000..5779a17
--- /dev/null
+++ b/SeaHaven.Services/Helpers/WorkOrderOperationalWeek.cs
@@ -0,0 +1,20 @@
+namespace SeaHaven.Services.Helpers
+{
+    public static class WorkOrderOperationalWeek
+    {
+        public static DateOnly GetMondayOfWeek(DateOnly date)
+        {
+            var daysFromMonday = ((int)date.DayOfWeek + 6) % 7;
+            return date.AddDays(-daysFromMonday);
+        }
+
+        public static DateOnly GetPreviousOperationalWeekStart(DateTime utcNow)
+            => GetMondayOfWeek(DateOnly.FromDateTime(utcNow)).AddDays(-7);
+
+        public static DateOnly GetOperationalWeekEnd(DateOnly weekStartMonday)
+            => weekStartMonday.AddDays(4);
+
+        public static string BuildWeekCorrelationId(DateOnly sourceWeekStart)
+            => $"week:{sourceWeekStart:yyyy-MM-dd}";
+    }
+}
diff --git a/SeaHaven.Services/Helpers/WorkOrderSearchDateRangeResolver.cs b/SeaHaven.Services/Helpers/WorkOrderSearchDateRangeResolver.cs
new file mode 100644
index 0000000..48a8f48
--- /dev/null
+++ b/SeaHaven.Services/Helpers/WorkOrderSearchDateRangeResolver.cs
@@ -0,0 +1,95 @@
+namespace SeaHaven.Services.Helpers
+{
+    public enum WorkOrderAdvancedSearchDatePreset
+    {
+        ThisWeek,
+        LastWeek,
+        ThisMonth,
+        Last3Months,
+        NextWeek,
+        NextMonth,
+        Custom
+    }
+
+    public record WorkOrderSearchDateRange(DateOnly From, DateOnly To);
+
+    public static class WorkOrderSearchDateRangeResolver
+    {
+        public static WorkOrderSearchDateRange Resolve(
+            WorkOrderAdvancedSearchDatePreset? preset,
+            DateOnly? dateFrom,
+            DateOnly? dateTo,
+            DateOnly? referenceDate = null)
+        {
+            var today = referenceDate ?? DateOnly.FromDateTime(DateTime.UtcNow);
+            var resolvedPreset = preset ?? WorkOrderAdvancedSearchDatePreset.ThisWeek;
+
+            if (resolvedPreset == WorkOrderAdvancedSearchDatePreset.Custom)
+            {
+                if (!dateFrom.HasValue || !dateTo.HasValue)
+                    throw new ArgumentException("dateFrom and dateTo are required when datePreset is custom.");
+
+                if (dateTo.Value < dateFrom.Value)
+                    throw new ArgumentException("dateTo must be on or after dateFrom.");
+
+                return new WorkOrderSearchDateRange(dateFrom.Value, dateTo.Value);
+            }
+
+            return resolvedPreset switch
+            {
+                WorkOrderAdvancedSearchDatePreset.ThisWeek => ThisIsoWeek(today),
+                WorkOrderAdvancedSearchDatePreset.LastWeek => LastIsoWeek(today),
+                WorkOrderAdvancedSearchDatePreset.ThisMonth => ThisMonth(today),
+                WorkOrderAdvancedSearchDatePreset.Last3Months => Last3Months(today),
+                WorkOrderAdvancedSearchDatePreset.NextWeek => NextIsoWeek(today),
+                WorkOrderAdvancedSearchDatePreset.NextMonth => NextMonth(today),
+                _ => ThisIsoWeek(today)
+            };
+        }
+
+        public static DateOnly GetIsoWeekStart(DateOnly date)
+        {
+            var diff = (7 + (date.DayOfWeek - DayOfWeek.Monday)) % 7;
+            return date.AddDays(-diff);
+        }
+
+        private static WorkOrderSearchDateRange ThisIsoWeek(DateOnly today)
+        {
+            var start = GetIsoWeekStart(today);
+            return new WorkOrderSearchDateRange(start, start.AddDays(4));
+        }
+
+        private static WorkOrderSearchDateRange LastIsoWeek(DateOnly today)
+        {
+            var start = GetIsoWeekStart(today).AddDays(-7);
+            return new WorkOrderSearchDateRange(start, start.AddDays(4));
+        }
+
+        private static WorkOrderSearchDateRange NextIsoWeek(DateOnly today)
+        {
+            var start = GetIsoWeekStart(today).AddDays(7);
+            return new WorkOrderSearchDateRange(start, start.AddDays(4));
+        }
+
+        private static WorkOrderSearchDateRange ThisMonth(DateOnly today)
+        {
+            var start = new DateOnly(today.Year, today.Month, 1);
+            var end = start.AddMonths(1).AddDays(-1);
+            return new WorkOrderSearchDateRange(start, end);
+        }
+
+        private static WorkOrderSearchDateRange NextMonth(DateOnly today)
+        {
+            var start = new DateOnly(today.Year, today.Month, 1).AddMonths(1);
+            var end = start.AddMonths(1).AddDays(-1);
+            return new WorkOrderSearchDateRange(start, end);
+        }
+
+        private static WorkOrderSearchDateRange Last3Months(DateOnly today)
+        {
+            var end = today;
+            var start = today.AddMonths(-3);
+            return new WorkOrderSearchDateRange(start, end);
+        }
+    }
+}
diff --git a/SeaHaven.Services/Helpers/WorkOrderTypeMapper.cs b/SeaHaven.Services/Helpers/WorkOrderTypeMapper.cs
new file mode 100644
index 0000000..4eda69f
--- /dev/null
+++ b/SeaHaven.Services/Helpers/WorkOrderTypeMapper.cs
@@ -0,0 +1,47 @@
+using Data.SeaHavenIndustries.Enums;
+
+namespace SeaHaven.Services.Helpers
+{
+    public static class WorkOrderTypeMapper
+    {
+        /// <summary>Board FE types. Overdue is not a type — use <see cref="WorkOrderDerivedFields.IsPastDue(System.DateTime?, LifecycleStatus?, System.DateTime?)"/>.</summary>
+        public static bool TryParseFeLabel(string? label, out WorkOrderType type)
+        {
+            type = default;
+            if (string.IsNullOrWhiteSpace(label)) return false;
+
+            return label.Trim().ToLowerInvariant() switch
+            {
+                "pm" => Set(WorkOrderType.PM, out type),
+                "reactive" => Set(WorkOrderType.Reactive, out type),
+                "emergency" => Set(WorkOrderType.Emergency, out type),
+                "add-on" or "addon" => Set(WorkOrderType.AddOn, out type),
+                "po" => Set(WorkOrderType.PO, out type),
+                "project" => Set(WorkOrderType.Project, out type),
+                "inspection" => Set(WorkOrderType.Inspection, out type),
+                "other" => Set(WorkOrderType.Other, out type),
+                "overdue" => false,
+                _ => Enum.TryParse(label, true, out type)
+            };
+        }
+
+        public static string ToFeLabel(WorkOrderType type) => type switch
+        {
+            WorkOrderType.PM => "PM",
+            WorkOrderType.Reactive => "Reactive",
+            WorkOrderType.Emergency => "Emergency",
+            WorkOrderType.AddOn => "Add-On",
+            WorkOrderType.PO => "PO",
+            WorkOrderType.Project => "Project",
+            WorkOrderType.Inspection => "Inspection",
+            WorkOrderType.Other => "Other",
+            _ => type.ToString()
+        };
+
+        private static bool Set(WorkOrderType value, out WorkOrderType type)
+        {
+            type = value;
+            return true;
+        }
+    }
+}
diff --git a/SeaHaven.Services/Implementation/LocationService.cs b/SeaHaven.Services/Implementation/LocationService.cs
index c625192..accf6ba 100644
--- a/SeaHaven.Services/Implementation/LocationService.cs
+++ b/SeaHaven.Services/Implementation/LocationService.cs
@@ -64,6 +64,20 @@ namespace SeaHaven.Services.Implementation
             };
         }
 
+        public async Task<IReadOnlyList<SiteOptionDTO>> GetSiteOptionsAsync(string? search = null)
+        {
+            var rows = await _locationDataService.GetSiteOptionsAsync(search);
+            return rows
+                .Select(r => new SiteOptionDTO
+                {
+                    Id = r.Id,
+                    Code = r.Code,
+                    City = r.City,
+                    State = r.State
+                })
+                .ToList();
+        }
+
         public async Task<LocationDTO> CreateLocationAsync(CreateLocationDTO dto, string userId)
         {
             var validationResult = await _createValidator.ValidateAsync(dto);
diff --git a/SeaHaven.Services/Implementation/PastDueCacheService.cs b/SeaHaven.Services/Implementation/PastDueCacheService.cs
new file mode 100644
index 0000000..33c1646
--- /dev/null
+++ b/SeaHaven.Services/Implementation/PastDueCacheService.cs
@@ -0,0 +1,48 @@
+using System.Diagnostics;
+using Microsoft.Extensions.Logging;
+using SeaHaven.DataServices.Interfaces;
+using SeaHaven.Services.DTOs;
+using SeaHaven.Services.Interfaces;
+
+namespace SeaHaven.Services.Implementation
+{
+    public class PastDueCacheService : IPastDueCacheService
+    {
+        private readonly IWorkOrderDomainJobDataService _dataService;
+        private readonly ILogger<PastDueCacheService> _logger;
+
+        public PastDueCacheService(
+            IWorkOrderDomainJobDataService dataService,
+            ILogger<PastDueCacheService> logger)
+        {
+            _dataService = dataService;
+            _logger = logger;
+        }
+
+        public async Task<PastDueCacheJobResult> RefreshAsync(CancellationToken cancellationToken = default)
+        {
+            var stopwatch = Stopwatch.StartNew();
+            var utcNow = DateTime.UtcNow;
+
+            _logger.LogInformation("PastDue cache refresh started at {UtcNow}", utcNow);
+
+            var refreshResult = await _dataService.RefreshPastDueFlagsAsync(utcNow, cancellationToken: cancellationToken);
+
+            stopwatch.Stop();
+
+            var result = new PastDueCacheJobResult
+            {
+                SetCount = refreshResult.SetCount,
+                ClearedCount = refreshResult.ClearedCount,
+                ExaminedCount = refreshResult.ExaminedCount,
+                DurationMs = stopwatch.ElapsedMilliseconds
+            };
+
+            _logger.LogInformation(
+                "PastDue cache refresh completed. Set={SetCount}, Cleared={ClearedCount}, Examined={ExaminedCount}, DurationMs={DurationMs}",
+                result.SetCount, result.ClearedCount, result.ExaminedCount, result.DurationMs);
+
+            return result;
+        }
+    }
+}
diff --git a/SeaHaven.Services/Implementation/SyncFieldMergePolicy.cs b/SeaHaven.Services/Implementation/SyncFieldMergePolicy.cs
new file mode 100644
index 0000000..eefdcbd
--- /dev/null
+++ b/SeaHaven.Services/Implementation/SyncFieldMergePolicy.cs
@@ -0,0 +1,219 @@
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+using SeaHaven.Services.Constants;
+using SeaHaven.Services.Interfaces;
+
+namespace SeaHaven.Services.Implementation
+{
+    public class SyncFieldMergePolicy : ISyncFieldMergePolicy
+    {
+        private static readonly HashSet<string> ShocOwnedFieldSet = new(StringComparer.OrdinalIgnoreCase)
+        {
+            WorkOrderFieldNames.LifecycleStatus,
+            WorkOrderFieldNames.AssignTo,
+            WorkOrderFieldNames.ScheduledDate,
+            WorkOrderFieldNames.ScheduledEnd,
+            WorkOrderFieldNames.TargetWeek,
+            WorkOrderFieldNames.ScheduleWeekOnly,
+            WorkOrderFieldNames.DueDate,
+            WorkOrderFieldNames.Description,
+            WorkOrderFieldNames.WorkerOrderTitle,
+            WorkOrderFieldNames.SiteCode,
+            WorkOrderFieldNames.Building,
+            WorkOrderFieldNames.LocationId,
+            WorkOrderFieldNames.WorkOrderType,
+            WorkOrderFieldNames.Service,
+            WorkOrderFieldNames.DocStatus,
+            WorkOrderFieldNames.Trade,
+            WorkOrderFieldNames.Problem,
+            WorkOrderFieldNames.Priority,
+            WorkOrderFieldNames.InternalWONumber,
+            WorkOrderFieldNames.Status,
+        };
+
+        private readonly IWorkOrderFieldLockService _fieldLocks;
+
+        public SyncFieldMergePolicy(IWorkOrderFieldLockService fieldLocks)
+        {
+            _fieldLocks = fieldLocks;
+        }
+
+        public IReadOnlySet<string> ShocOwnedFields => ShocOwnedFieldSet;
+
+        public async Task<bool> CanSyncOverwriteAsync(int workOrderId, string fieldName)
+            => !await _fieldLocks.IsLockedAsync(workOrderId, fieldName);
+
+        public async Task<bool> TryApplyAsync(WorkOrderSyncContext context, string fieldName, object? incomingValue)
+        {
+            if (incomingValue == null) return false;
+
+            if (await context.FieldLocks.IsLockedAsync(context.WorkOrder.Id, fieldName))
+            {
+                var current = GetFieldValue(context.WorkOrder, fieldName);
+                await context.Audit.LogSyncRejectedAsync(
+                    context.WorkOrder.Id,
+                    fieldName,
+                    current,
+                    incomingValue.ToString());
+                return false;
+            }
+
+            return TryApplyField(context.WorkOrder, fieldName, incomingValue);
+        }
+
+        private static string? GetFieldValue(WorkOrder wo, string fieldName) => fieldName switch
+        {
+            WorkOrderFieldNames.Description => wo.Description,
+            WorkOrderFieldNames.WorkerOrderTitle => wo.WorkerOrderTitle,
+            WorkOrderFieldNames.Status => wo.Status,
+            WorkOrderFieldNames.DueDate => wo.DueDate?.ToString("O"),
+            WorkOrderFieldNames.ScheduledDate => wo.ScheduledDate?.ToString("O"),
+            WorkOrderFieldNames.ScheduledEnd => wo.ScheduledEnd?.ToString("O"),
+            WorkOrderFieldNames.TargetWeek => wo.TargetWeek?.ToString("O"),
+            WorkOrderFieldNames.ScheduleWeekOnly => wo.ScheduleWeekOnly?.ToString(),
+            WorkOrderFieldNames.SiteCode => wo.SiteCode,
+            WorkOrderFieldNames.Building => wo.Building,
+            WorkOrderFieldNames.Priority => wo.Priority,
+            WorkOrderFieldNames.AssignTo => wo.AssignTo,
+            WorkOrderFieldNames.LocationId => wo.LocationId?.ToString(),
+            WorkOrderFieldNames.LifecycleStatus => wo.LifecycleStatus?.ToString(),
+            WorkOrderFieldNames.WorkOrderType => wo.WorkOrderType?.ToString(),
+            WorkOrderFieldNames.Service => wo.Service,
+            WorkOrderFieldNames.DocStatus => wo.DocStatus?.ToString(),
+            WorkOrderFieldNames.Trade => wo.Trade,
+            WorkOrderFieldNames.Problem => wo.Problem,
+            WorkOrderFieldNames.InternalWONumber => wo.InternalWONumber,
+            _ => null
+        };
+
+        private static bool TryApplyField(WorkOrder wo, string fieldName, object incomingValue)
+        {
+            switch (fieldName)
+            {
+                case WorkOrderFieldNames.Description:
+                    wo.Description = incomingValue.ToString();
+                    return true;
+                case WorkOrderFieldNames.WorkerOrderTitle:
+                    wo.WorkerOrderTitle = incomingValue.ToString();
+                    return true;
+                case WorkOrderFieldNames.Status:
+                    wo.Status = incomingValue.ToString();
+                    return true;
+                case WorkOrderFieldNames.DueDate when TryParseDateTime(incomingValue, out var dueDate):
+                    wo.DueDate = dueDate;
+                    return true;
+                case WorkOrderFieldNames.ScheduledDate when TryParseDateTime(incomingValue, out var scheduledDate):
+                    wo.ScheduledDate = scheduledDate;
+                    return true;
+                case WorkOrderFieldNames.ScheduledEnd when TryParseDateTime(incomingValue, out var scheduledEnd):
+                    wo.ScheduledEnd = scheduledEnd;
+                    return true;
+                case WorkOrderFieldNames.TargetWeek when TryParseDateOnly(incomingValue, out var targetWeek):
+                    wo.TargetWeek = targetWeek;
+                    return true;
+                case WorkOrderFieldNames.ScheduleWeekOnly when TryParseBool(incomingValue, out var scheduleWeekOnly):
+                    wo.ScheduleWeekOnly = scheduleWeekOnly;
+                    return true;
+                case WorkOrderFieldNames.SiteCode:
+                    wo.SiteCode = incomingValue.ToString();
+                    return true;
+                case WorkOrderFieldNames.Building:
+                    wo.Building = incomingValue.ToString();
+                    return true;
+                case WorkOrderFieldNames.Priority:
+                    wo.Priority = incomingValue.ToString();
+                    return true;
+                case WorkOrderFieldNames.AssignTo:
+                    wo.AssignTo = incomingValue.ToString();
+                    return true;
+                case WorkOrderFieldNames.LocationId when TryParseInt(incomingValue, out var locationId):
+                    wo.LocationId = locationId;
+                    return true;
+                case WorkOrderFieldNames.LifecycleStatus when TryParseEnum(incomingValue, out LifecycleStatus lifecycleStatus):
+                    wo.LifecycleStatus = lifecycleStatus;
+                    return true;
+                case WorkOrderFieldNames.WorkOrderType when TryParseEnum(incomingValue, out WorkOrderType workOrderType):
+                    wo.WorkOrderType = workOrderType;
+                    return true;
+                case WorkOrderFieldNames.Service:
+                    wo.Service = incomingValue.ToString();
+                    return true;
+                case WorkOrderFieldNames.DocStatus when TryParseEnum(incomingValue, out DocStatus docStatus):
+                    wo.DocStatus = docStatus;
+                    return true;
+                case WorkOrderFieldNames.Trade:
+                    wo.Trade = incomingValue.ToString();
+                    return true;
+                case WorkOrderFieldNames.Problem:
+                    wo.Problem = incomingValue.ToString();
+                    return true;
+                case WorkOrderFieldNames.InternalWONumber:
+                    wo.InternalWONumber = incomingValue.ToString();
+                    return true;
+                default:
+                    return false;
+            }
+        }
+
+        private static bool TryParseDateTime(object value, out DateTime result)
+        {
+            if (value is DateTime dt)
+            {
+                result = dt;
+                return true;
+            }
+
+            return DateTime.TryParse(value.ToString(), out result);
+        }
+
+        private static bool TryParseDateOnly(object value, out DateOnly result)
+        {
+            if (value is DateOnly dateOnly)
+            {
+                result = dateOnly;
+                return true;
+            }
+
+            if (value is DateTime dt)
+            {
+                result = DateOnly.FromDateTime(dt);
+                return true;
+            }
+
+            return DateOnly.TryParse(value.ToString(), out result);
+        }
+
+        private static bool TryParseBool(object value, out bool result)
+        {
+            if (value is bool b)
+            {
+                result = b;
+                return true;
+            }
+
+            return bool.TryParse(value.ToString(), out result);
+        }
+
+        private static bool TryParseInt(object value, out int result)
+        {
+            if (value is int i)
+            {
+                result = i;
+                return true;
+            }
+
+            return int.TryParse(value.ToString(), out result);
+        }
+
+        private static bool TryParseEnum<TEnum>(object value, out TEnum result) where TEnum : struct, Enum
+        {
+            if (value is TEnum enumValue)
+            {
+                result = enumValue;
+                return true;
+            }
+
+            return Enum.TryParse(value.ToString(), true, out result);
+        }
+    }
+}
diff --git a/SeaHaven.Services/Implementation/WorkOrderAdvancedSearchService.cs b/SeaHaven.Services/Implementation/WorkOrderAdvancedSearchService.cs
new file mode 100644
index 0000000..8b35a1a
--- /dev/null
+++ b/SeaHaven.Services/Implementation/WorkOrderAdvancedSearchService.cs
@@ -0,0 +1,66 @@
+using SeaHaven.DataServices.Helpers;
+using SeaHaven.DataServices.Interfaces;
+using SeaHaven.Services.DTOs;
+using SeaHaven.Services.Helpers;
+using SeaHaven.Services.Interfaces;
+
+namespace SeaHaven.Services.Implementation
+{
+    public class WorkOrderAdvancedSearchService : IWorkOrderAdvancedSearchService
+    {
+        private const int DefaultPageSize = 100;
+        private const int MaxPageSize = 100;
+
+        private readonly IWorkOrderAdvancedSearchDataService _searchDataService;
+
+        public WorkOrderAdvancedSearchService(IWorkOrderAdvancedSearchDataService searchDataService)
+        {
+            _searchDataService = searchDataService;
+        }
+
+        public async Task<PagedResult<WorkOrderBoardRowDto>> SearchAsync(
+            WorkOrderAdvancedSearchQueryDto query,
+            string? currentUserId)
+        {
+            var page = query.Page < 0 ? 0 : query.Page;
+            var pageSize = query.PageSize < 1 ? DefaultPageSize : Math.Min(query.PageSize, MaxPageSize);
+
+            var dateRange = WorkOrderSearchDateRangeResolver.Resolve(
+                query.DatePreset,
+                query.DateFrom,
+                query.DateTo);
+
+            var sortBy = WorkOrderBoardSortFields.NormalizeOrThrow(query.SortBy);
+
+            var dataQuery = new WorkOrderAdvancedSearchQuery(
+                WorkOrderBoardSearchFilter.NormalizeSearch(query.Search),
+                dateRange.From,
+                dateRange.To,
+                query.Sites,
+                query.Types,
+                query.Dispatchers,
+                query.Statuses,
+                query.PmTypes,
+                query.VendorIds,
+                query.DocStatuses,
+                query.MyWorkOrders,
+                currentUserId,
+                page,
+                pageSize,
+                sortBy,
+                query.SortDir ?? "asc");
+
+            var result = await _searchDataService.SearchAsync(dataQuery);
+            var utcNow = DateTime.UtcNow;
+
+            return new PagedResult<WorkOrderBoardRowDto>
+            {
+                Items = result.Rows.Select(r => WorkOrderBoardService.MapRawRow(r, utcNow)).ToList(),
+                TotalCount = result.TotalCount,
+                Page = page,
+                PageSize = pageSize,
+                PageBase = 0
+            };
+        }
+    }
+}
diff --git a/SeaHaven.Services/Implementation/WorkOrderAuditService.cs b/SeaHaven.Services/Implementation/WorkOrderAuditService.cs
new file mode 100644
index 0000000..86087de
--- /dev/null
+++ b/SeaHaven.Services/Implementation/WorkOrderAuditService.cs
@@ -0,0 +1,144 @@
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+using Microsoft.EntityFrameworkCore;
+using SeaHaven.Services.Interfaces;
+
+namespace SeaHaven.Services.Implementation
+{
+    public class WorkOrderAuditService : IWorkOrderAuditService
+    {
+        private readonly ApplicationDbContext _context;
+        private readonly IWorkOrderFieldLockService _fieldLocks;
+
+        public WorkOrderAuditService(ApplicationDbContext context, IWorkOrderFieldLockService fieldLocks)
+        {
+            _context = context;
+            _fieldLocks = fieldLocks;
+        }
+
+        public Task LogStatusChangedAsync(int workOrderId, string? oldStatus, string? newStatus, string? actorId)
+            => LogAsync(workOrderId, AuditActionType.StatusChanged, AuditEventType.Manual,
+                AuditActorType.Dispatcher, "LifecycleStatus", oldStatus, newStatus, actorId);
+
+        public Task LogAssignmentChangedAsync(int workOrderId, string? oldValue, string? newValue, string? actorId)
+            => LogAsync(workOrderId, AuditActionType.AssignmentChanged, AuditEventType.Manual,
+                AuditActorType.Dispatcher, "AssignTo", oldValue, newValue, actorId);
+
+        public Task LogSyncRejectedAsync(int workOrderId, string fieldName, string? oldValue, string? newValue)
+            => LogAsync(workOrderId, AuditActionType.SyncRejected, AuditEventType.Sync,
+                AuditActorType.Sync, fieldName, oldValue, newValue);
+
+        public Task LogWeekRolledAsync(int workOrderId, int oldCarriedOver, int newCarriedOver, string correlationId)
+            => LogAsync(
+                workOrderId,
+                AuditActionType.WeekRolled,
+                AuditEventType.System,
+                AuditActorType.System,
+                "CarriedOver",
+                oldCarriedOver.ToString(),
+                newCarriedOver.ToString(),
+                correlationId: correlationId);
+
+        public void StageFieldChanged(int workOrderId, string fieldName, string? oldValue, string? newValue, string? actorId, int? dispatchId = null)
+            => StageAudit(workOrderId, AuditActionType.FieldChanged, fieldName, oldValue, newValue, actorId, dispatchId);
+
+        public void StageStatusChanged(int workOrderId, string? oldStatus, string? newStatus, string? actorId)
+            => StageAudit(workOrderId, AuditActionType.StatusChanged, "LifecycleStatus", oldStatus, newStatus, actorId);
+
+        public void StageAssignmentChanged(int workOrderId, string? oldValue, string? newValue, string? actorId)
+            => StageAudit(workOrderId, AuditActionType.AssignmentChanged, "AssignTo", oldValue, newValue, actorId);
+
+        public void StageCreated(int workOrderId, string? actorId, string? woNumber)
+            => StageAudit(workOrderId, AuditActionType.Create, "WorkOrder", null, woNumber, actorId);
+
+        public async Task LogAsync(
+            int workOrderId,
+            AuditActionType action,
+            AuditEventType eventType,
+            AuditActorType actorType,
+            string fieldName,
+            string? oldValue,
+            string? newValue,
+            string? actorId = null,
+            int? dispatchId = null,
+            string? correlationId = null)
+        {
+            AddAuditEntry(workOrderId, action, eventType, actorType, fieldName, oldValue, newValue, actorId, dispatchId, correlationId);
+
+            if (eventType == AuditEventType.Manual &&
+                (action == AuditActionType.FieldChanged ||
+                 action == AuditActionType.StatusChanged ||
+                 action == AuditActionType.AssignmentChanged))
+            {
+                await _fieldLocks.LockFieldAsync(workOrderId, fieldName, actorId);
+            }
+
+            await _context.SaveChangesAsync();
+        }
+
+        private void StageAudit(
+            int workOrderId,
+            AuditActionType action,
+            string fieldName,
+            string? oldValue,
+            string? newValue,
+            string? actorId,
+            int? dispatchId = null)
+        {
+            AddAuditEntry(workOrderId, action, AuditEventType.Manual, AuditActorType.Dispatcher,
+                fieldName, oldValue, newValue, actorId, dispatchId);
+            StageFieldLock(workOrderId, fieldName, actorId);
+        }
+
+        private void AddAuditEntry(
+            int workOrderId,
+            AuditActionType action,
+            AuditEventType eventType,
+            AuditActorType actorType,
+            string fieldName,
+            string? oldValue,
+            string? newValue,
+            string? actorId,
+            int? dispatchId = null,
+            string? correlationId = null)
+        {
+            _context.WorkOrderAuditLogs.Add(new WorkOrderAuditLog
+            {
+                WorkOrderId = workOrderId,
+                UserId = actorId,
+                FieldName = fieldName,
+                OldValue = oldValue ?? "",
+                NewValue = newValue ?? "",
+                Action = action.ToString(),
+                EventType = eventType.ToString(),
+                ActorType = actorType.ToString(),
+                DispatchId = dispatchId,
+                CorrelationId = correlationId,
+                CreatedAt = DateTime.UtcNow
+            });
+        }
+
+        private void StageFieldLock(int workOrderId, string fieldName, string? userId)
+        {
+            if (_context.WorkOrderFieldLocks.Local.Any(l =>
+                    l.WorkOrderId == workOrderId &&
+                    string.Equals(l.FieldName, fieldName, StringComparison.OrdinalIgnoreCase)))
+                return;
+
+            var existsInDb = _context.WorkOrderFieldLocks.Any(l =>
+                l.WorkOrderId == workOrderId &&
+                l.FieldName == fieldName);
+
+            if (existsInDb)
+                return;
+
+            _context.WorkOrderFieldLocks.Add(new WorkOrderFieldLock
+            {
+                WorkOrderId = workOrderId,
+                FieldName = fieldName,
+                LockedAt = DateTime.UtcNow,
+                LockedByUserId = userId
+            });
+        }
+    }
+}
diff --git a/SeaHaven.Services/Implementation/WorkOrderBoardCancelService.cs b/SeaHaven.Services/Implementation/WorkOrderBoardCancelService.cs
new file mode 100644
index 0000000..273e26f
--- /dev/null
+++ b/SeaHaven.Services/Implementation/WorkOrderBoardCancelService.cs
@@ -0,0 +1,57 @@
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+using Microsoft.EntityFrameworkCore;
+using SeaHaven.Services.DTOs;
+using SeaHaven.Services.Exceptions;
+using SeaHaven.Services.Helpers;
+using SeaHaven.Services.Interfaces;
+
+namespace SeaHaven.Services.Implementation
+{
+    public class WorkOrderBoardCancelService : IWorkOrderBoardCancelService
+    {
+        private readonly ApplicationDbContext _context;
+        private readonly IWorkOrderBoardService _boardService;
+        private readonly IWorkOrderAuditService _auditService;
+
+        public WorkOrderBoardCancelService(
+            ApplicationDbContext context,
+            IWorkOrderBoardService boardService,
+            IWorkOrderAuditService auditService)
+        {
+            _context = context;
+            _boardService = boardService;
+            _auditService = auditService;
+        }
+
+        public async Task<WorkOrderBoardRowDto> CancelAsync(int workOrderId, string? actorId)
+        {
+            var workOrder = await _context.workOrders
+                .FirstOrDefaultAsync(w => w.Id == workOrderId && w.istemplate != true && (w.IsDeleted != true || w.IsDeleted == null));
+
+            if (workOrder == null)
+                throw new WorkOrderBoardValidationException("NotFound", "Work order not found.");
+
+            if (workOrder.LifecycleStatus == LifecycleStatus.Canceled)
+            {
+                var existing = await _boardService.GetBoardRowAsync(workOrderId);
+                return existing ?? throw new WorkOrderBoardValidationException("NotFound", "Work order not found.");
+            }
+
+            if (workOrder.LifecycleStatus == LifecycleStatus.Completed)
+                throw new WorkOrderBoardValidationException("CancelNotAllowed", "Work order cannot be canceled in its current status.");
+
+            var oldStatus = workOrder.LifecycleStatus?.ToString() ?? workOrder.Status ?? "";
+            workOrder.LifecycleStatus = LifecycleStatus.Canceled;
+            workOrder.Status = WorkOrderDerivedFields.GetLifecycleStatusLabel(LifecycleStatus.Canceled);
+            if (workOrder.LegacyStatus == null && workOrder.Status != null)
+                workOrder.LegacyStatus = workOrder.Status;
+
+            _auditService.StageStatusChanged(workOrderId, oldStatus, LifecycleStatus.Canceled.ToString(), actorId);
+            await _context.SaveChangesAsync();
+
+            var row = await _boardService.GetBoardRowAsync(workOrderId);
+            return row ?? throw new WorkOrderBoardValidationException("NotFound", "Work order not found.");
+        }
+    }
+}
diff --git a/SeaHaven.Services/Implementation/WorkOrderBoardCreateService.cs b/SeaHaven.Services/Implementation/WorkOrderBoardCreateService.cs
new file mode 100644
index 0000000..7f75baa
--- /dev/null
+++ b/SeaHaven.Services/Implementation/WorkOrderBoardCreateService.cs
@@ -0,0 +1,305 @@
+using System.Text.Json;
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+using FluentValidation;
+using Microsoft.EntityFrameworkCore;
+using SeaHaven.DataServices.Interfaces;
+using SeaHaven.Services.DTOs;
+using SeaHaven.Services.Exceptions;
+using SeaHaven.Services.Helpers;
+using SeaHaven.Services.Interfaces;
+using SeaHaven.Services.Validation;
+
+namespace SeaHaven.Services.Implementation
+{
+    public class WorkOrderBoardCreateService : IWorkOrderBoardCreateService
+    {
+        private readonly ApplicationDbContext _context;
+        private readonly IWorkOrderBoardDataService _boardDataService;
+        private readonly IWorkOrderBoardService _boardService;
+        private readonly IWorkOrderAuditService _auditService;
+        private readonly IWorkOrderBoardCreateValidation _validator;
+
+        public WorkOrderBoardCreateService(
+            ApplicationDbContext context,
+            IWorkOrderBoardDataService boardDataService,
+            IWorkOrderBoardService boardService,
+            IWorkOrderAuditService auditService,
+            IWorkOrderBoardCreateValidation validator)
+        {
+            _context = context;
+            _boardDataService = boardDataService;
+            _boardService = boardService;
+            _auditService = auditService;
+            _validator = validator;
+        }
+
+        public async Task<WorkOrderBoardRowDto> CreateAsync(WorkOrderBoardCreateRequestDto request, string? actorId)
+        {
+            var validationResult = await _validator.ValidateAsync(request);
+            if (!validationResult.IsValid)
+                throw new ValidationException(validationResult.Errors);
+
+            var woNumber = await ResolveWoNumberAsync(request.WoNumber);
+            var siteCode = request.SiteCode!.Trim();
+            var primaryService = ResolvePrimaryService(request);
+            var extraServicesJson = SerializeExtraServices(request.ExtraServices);
+            var serviceNotes = TrimOrNull(request.ServiceNotes);
+            var pocName = TrimOrNull(request.PocName);
+            var pocPhone = TrimOrNull(request.PocPhone);
+            var pocNotes = TrimOrNull(request.PocNotes);
+            var techPhone = TrimOrNull(request.TechPhone);
+            var vendorNotes = TrimOrNull(request.VendorNotes);
+            var hasVendorDispatch = request.VendorId.HasValue
+                || request.ApptDate.HasValue
+                || !string.IsNullOrWhiteSpace(request.ApptTime);
+
+            if (request.VendorId.HasValue && request.VendorId.Value > 0)
+            {
+                var vendorExists = await _context.Vendors.AnyAsync(v => v.Id == request.VendorId.Value && v.IsDeleted != true);
+                if (!vendorExists)
+                    throw new WorkOrderBoardValidationException("VendorNotFound", "vendorId does not exist.");
+            }
+
+            var workOrder = new WorkOrder
+            {
+                InternalWONumber = woNumber,
+                WorkerOrderNumber = woNumber,
+                WorkOrderType = request.WorkOrderType,
+                SiteCode = siteCode,
+                Description = string.IsNullOrWhiteSpace(request.Description) ? null : request.Description.Trim(),
+                Trade = primaryService,
+                ExtraServices = extraServicesJson,
+                ServiceNotes = serviceNotes,
+                PocName = pocName,
+                PocPhone = pocPhone,
+                PocNotes = pocNotes,
+                LocationId = request.LocationId,
+                DueDate = request.DueDate?.Date,
+                AssignTo = string.IsNullOrWhiteSpace(request.AssignTo) ? null : request.AssignTo.Trim(),
+                TargetWeek = request.TargetWeek,
+                ScheduleWeekOnly = request.ScheduleWeekOnly,
+                DocStatus = request.DocStatus,
+                createdby = actorId,
+                CreatedDate = DateTime.UtcNow,
+                istemplate = false
+            };
+
+            if (!hasVendorDispatch)
+            {
+                workOrder.TechPhone = techPhone;
+                workOrder.VendorNotes = vendorNotes;
+            }
+
+            WorkOrderBoardFieldMutations.SetInitialLifecycleStatus(workOrder);
+
+            var changes = new List<WorkOrderBoardFieldMutations.BoardFieldChange>
+            {
+                WorkOrderBoardFieldMutations.BoardFieldChange.Changed("InternalWONumber", "", woNumber),
+                WorkOrderBoardFieldMutations.BoardFieldChange.Changed("WorkOrderType", "", request.WorkOrderType.ToString()),
+                WorkOrderBoardFieldMutations.BoardFieldChange.Changed("SiteCode", "", siteCode),
+                WorkOrderBoardFieldMutations.BoardFieldChange.Changed("LifecycleStatus", "", LifecycleStatus.Incomplete.ToString())
+            };
+
+            if (workOrder.Description != null)
+                changes.Add(WorkOrderBoardFieldMutations.BoardFieldChange.Changed("Description", "", workOrder.Description));
+            if (workOrder.Trade != null)
+                changes.Add(WorkOrderBoardFieldMutations.BoardFieldChange.Changed("Trade", "", workOrder.Trade));
+            if (workOrder.ExtraServices != null)
+                changes.Add(WorkOrderBoardFieldMutations.BoardFieldChange.Changed("ExtraServices", "", workOrder.ExtraServices));
+            if (workOrder.ServiceNotes != null)
+                changes.Add(WorkOrderBoardFieldMutations.BoardFieldChange.Changed("ServiceNotes", "", workOrder.ServiceNotes));
+            if (workOrder.PocName != null)
+                changes.Add(WorkOrderBoardFieldMutations.BoardFieldChange.Changed("PocName", "", workOrder.PocName));
+            if (workOrder.PocPhone != null)
+                changes.Add(WorkOrderBoardFieldMutations.BoardFieldChange.Changed("PocPhone", "", workOrder.PocPhone));
+            if (workOrder.PocNotes != null)
+                changes.Add(WorkOrderBoardFieldMutations.BoardFieldChange.Changed("PocNotes", "", workOrder.PocNotes));
+            if (workOrder.TechPhone != null)
+                changes.Add(WorkOrderBoardFieldMutations.BoardFieldChange.Changed("TechPhone", "", workOrder.TechPhone));
+            if (workOrder.VendorNotes != null)
+                changes.Add(WorkOrderBoardFieldMutations.BoardFieldChange.Changed("VendorNotes", "", workOrder.VendorNotes));
+            if (workOrder.LocationId.HasValue)
+                changes.Add(WorkOrderBoardFieldMutations.BoardFieldChange.Changed("LocationId", "", workOrder.LocationId.Value.ToString()));
+            if (workOrder.DueDate.HasValue)
+                changes.Add(WorkOrderBoardFieldMutations.BoardFieldChange.Changed("DueDate", "", workOrder.DueDate.Value.ToString("yyyy-MM-dd")));
+            if (workOrder.TargetWeek.HasValue)
+                changes.Add(WorkOrderBoardFieldMutations.BoardFieldChange.Changed("TargetWeek", "", workOrder.TargetWeek.Value.ToString("yyyy-MM-dd")));
+            if (workOrder.ScheduleWeekOnly.HasValue)
+                changes.Add(WorkOrderBoardFieldMutations.BoardFieldChange.Changed("ScheduleWeekOnly", "", workOrder.ScheduleWeekOnly.Value.ToString()));
+            if (workOrder.DocStatus.HasValue)
+                changes.Add(WorkOrderBoardFieldMutations.BoardFieldChange.Changed("DocStatus", "", workOrder.DocStatus.Value.ToString()));
+
+            if (!string.IsNullOrWhiteSpace(request.AssignTo))
+                changes.AddRange(WorkOrderBoardFieldMutations.ApplyAssignTo(workOrder, request.AssignTo));
+            else if (!string.IsNullOrWhiteSpace(workOrder.AssignTo))
+                changes.Add(WorkOrderBoardFieldMutations.BoardFieldChange.AssignmentChanged("AssignTo", "", workOrder.AssignTo));
+
+            if (request.ScheduledDate.HasValue)
+                changes.AddRange(WorkOrderBoardFieldMutations.ApplyScheduledDate(workOrder, request.ScheduledDate.Value.Date));
+
+            Dispatch? dispatch = null;
+            if (hasVendorDispatch)
+            {
+                if (!request.VendorId.HasValue || request.VendorId.Value <= 0)
+                    throw new WorkOrderBoardValidationException("DispatchRequired", "vendorId is required when setting appointment fields.");
+
+                dispatch = new Dispatch
+                {
+                    VendorId = request.VendorId.Value,
+                    Status = "Pending",
+                    CreatedDate = DateTime.UtcNow,
+                    ScheduledDate = request.ApptDate?.Date,
+                    TechPhone = techPhone,
+                    VendorNotes = vendorNotes
+                };
+                _context.Dispatches.Add(dispatch);
+                workOrder.PrimaryDispatch = dispatch;
+                changes.Add(WorkOrderBoardFieldMutations.BoardFieldChange.Changed("VendorId", "", request.VendorId.Value.ToString()));
+
+                if (request.ApptDate.HasValue)
+                    changes.Add(WorkOrderBoardFieldMutations.BoardFieldChange.Changed("ApptDate", "", request.ApptDate.Value.ToString("yyyy-MM-dd")));
+
+                if (!string.IsNullOrWhiteSpace(request.ApptTime))
+                {
+                    var apptChange = WorkOrderBoardFieldMutations.ApplyApptTime(workOrder, dispatch, request.ApptTime);
+                    if (apptChange.HasChanged)
+                        changes.Add(apptChange);
+                }
+
+                if (techPhone != null)
+                    changes.Add(WorkOrderBoardFieldMutations.BoardFieldChange.Changed("TechPhone", "", techPhone));
+                if (vendorNotes != null)
+                    changes.Add(WorkOrderBoardFieldMutations.BoardFieldChange.Changed("VendorNotes", "", vendorNotes));
+            }
+
+            _context.workOrders.Add(workOrder);
+            await _context.SaveChangesAsync();
+
+            if (dispatch != null && workOrder.PrimaryDispatchId == null)
+            {
+                workOrder.PrimaryDispatchId = dispatch.Id;
+                dispatch.WorkOrderId = workOrder.Id;
+            }
+
+            _auditService.StageCreated(workOrder.Id, actorId, woNumber);
+            StageChanges(workOrder.Id, changes, actorId, dispatch);
+
+            if (request.PocContactId.HasValue)
+            {
+                _context.WorkOrderContacts.Add(new WorkOrderContacts
+                {
+                    WorkorderId = workOrder.Id,
+                    ContactId = request.PocContactId,
+                    Notes = pocNotes
+                });
+            }
+
+            await _context.SaveChangesAsync();
+
+            var row = await _boardService.GetBoardRowAsync(workOrder.Id);
+            return row ?? throw new WorkOrderBoardValidationException("NotFound", "Work order was created but could not be loaded.");
+        }
+
+        private static string? ResolvePrimaryService(WorkOrderBoardCreateRequestDto request)
+        {
+            if (!string.IsNullOrWhiteSpace(request.PrimaryService))
+                return request.PrimaryService.Trim();
+            if (!string.IsNullOrWhiteSpace(request.Trade))
+                return request.Trade.Trim();
+            return null;
+        }
+
+        private static string? SerializeExtraServices(List<string>? extras)
+        {
+            if (extras == null || extras.Count == 0)
+                return null;
+
+            var normalized = new List<string>();
+            var seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+            foreach (var item in extras)
+            {
+                if (string.IsNullOrWhiteSpace(item))
+                    continue;
+                var trimmed = item.Trim();
+                if (trimmed.Length > 128)
+                    throw new WorkOrderBoardValidationException(
+                        "InvalidValue",
+                        "Each extra service must be at most 128 characters.");
+                if (!seen.Add(trimmed))
+                    continue;
+                normalized.Add(trimmed);
+            }
+
+            if (normalized.Count == 0)
+                return null;
+
+            var json = JsonSerializer.Serialize(normalized);
+            if (json.Length > 2000)
+                throw new WorkOrderBoardValidationException(
+                    "InvalidValue",
+                    "extraServices must serialize to at most 2000 characters.");
+
+            return json;
+        }
+
+        private static string? TrimOrNull(string? value)
+            => string.IsNullOrWhiteSpace(value) ? null : value.Trim();
+
+        private async Task<string> ResolveWoNumberAsync(string? requested)
+        {
+            if (!string.IsNullOrWhiteSpace(requested))
+            {
+                if (!WorkOrderNumberNormalizer.TryNormalize(requested, out var normalized, out var error))
+                    throw new WorkOrderBoardValidationException("InvalidWoNumber", error ?? "Invalid WO number.");
+
+                if (await _boardDataService.InternalWoNumberExistsAsync(normalized, 0))
+                    throw new WorkOrderBoardValidationException("DuplicateWoNumber", "WO number already exists.");
+
+                return normalized;
+            }
+
+            for (var attempt = 0; attempt < 20; attempt++)
+            {
+                var candidate = await GenerateNextSequentialWoNumberAsync();
+                if (!await _boardDataService.InternalWoNumberExistsAsync(candidate, 0))
+                    return candidate;
+            }
+
+            throw new WorkOrderBoardValidationException("WoNumberGenerationFailed", "Could not generate a unique WO number.");
+        }
+
+        private async Task<string> GenerateNextSequentialWoNumberAsync()
+        {
+            var maxId = await _context.workOrders.MaxAsync(w => (int?)w.Id) ?? 0;
+            var seed = Math.Max(maxId + 1, 1);
+            if (!WorkOrderNumberNormalizer.TryNormalize(seed.ToString(), out var normalized, out _))
+                normalized = seed.ToString().PadLeft(11, '0');
+            return normalized;
+        }
+
+        private void StageChanges(
+            int workOrderId,
+            IEnumerable<WorkOrderBoardFieldMutations.BoardFieldChange> changes,
+            string? actorId,
+            Dispatch? dispatch)
+        {
+            foreach (var change in changes.Where(c => c.HasChanged))
+            {
+                var dispatchId = change.DispatchId ?? (dispatch?.Id > 0 ? dispatch.Id : null);
+                switch (change.Action)
+                {
+                    case AuditActionType.StatusChanged:
+                        _auditService.StageStatusChanged(workOrderId, change.OldValue, change.NewValue, actorId);
+                        break;
+                    case AuditActionType.AssignmentChanged:
+                        _auditService.StageAssignmentChanged(workOrderId, change.OldValue, change.NewValue, actorId);
+                        break;
+                    default:
+                        _auditService.StageFieldChanged(workOrderId, change.FieldName, change.OldValue ?? "", change.NewValue, actorId, dispatchId);
+                        break;
+                }
+            }
+        }
+    }
+}
diff --git a/SeaHaven.Services/Implementation/WorkOrderBoardService.cs b/SeaHaven.Services/Implementation/WorkOrderBoardService.cs
new file mode 100644
index 0000000..56c576e
--- /dev/null
+++ b/SeaHaven.Services/Implementation/WorkOrderBoardService.cs
@@ -0,0 +1,147 @@
+using Data.SeaHavenIndustries.Enums;
+using SeaHaven.DataServices.Interfaces;
+using SeaHaven.Services.DTOs;
+using SeaHaven.Services.Helpers;
+using SeaHaven.Services.Interfaces;
+
+namespace SeaHaven.Services.Implementation
+{
+    public class WorkOrderBoardService : IWorkOrderBoardService
+    {
+        private readonly IWorkOrderBoardDataService _boardDataService;
+
+        public WorkOrderBoardService(IWorkOrderBoardDataService boardDataService)
+        {
+            _boardDataService = boardDataService;
+        }
+
+        public async Task<WorkOrderBoardResponseDto> GetBoardAsync(
+            WorkOrderBoardQueryDto query,
+            string? currentUserId)
+        {
+            var weekStart = query.WeekStart;
+            var weekEnd = query.WeekEnd ?? weekStart.AddDays(4);
+
+            ValidateWeekWindow(weekStart, weekEnd);
+
+            var dataQuery = new WorkOrderBoardQuery(
+                weekStart,
+                weekEnd,
+                query.Dispatchers,
+                query.MyWorkOrders,
+                query.Types,
+                query.Search,
+                currentUserId);
+
+            var result = await _boardDataService.GetBoardRowsAsync(dataQuery);
+            var utcNow = DateTime.UtcNow;
+
+            return new WorkOrderBoardResponseDto
+            {
+                WeekStart = weekStart,
+                WeekEnd = weekEnd,
+                Counts = new WorkOrderBoardCountsDto
+                {
+                    Total = result.ScheduledTotalBeforeSearch,
+                    Returned = result.ScheduledRows.Count
+                },
+                Scheduled = result.ScheduledRows.Select(r => MapRawRow(r, utcNow)).ToList(),
+                Unscheduled = result.UnscheduledRows.Select(r => MapRawRow(r, utcNow)).ToList()
+            };
+        }
+
+        public async Task<IReadOnlyList<DispatcherLookupDto>> GetDispatcherLookupsAsync()
+        {
+            var rows = await _boardDataService.GetDispatcherLookupsAsync();
+            return rows.Select(r => new DispatcherLookupDto
+            {
+                Id = r.Id,
+                Name = FormatName(r.FirstName, r.LastName),
+                Initials = r.Initials,
+                Color = r.Color
+            }).ToList();
+        }
+
+        public async Task<WorkOrderBoardRowDto?> GetBoardRowAsync(int workOrderId)
+        {
+            var raw = await _boardDataService.GetBoardRowByIdAsync(workOrderId);
+            return raw == null ? null : MapRawRow(raw, DateTime.UtcNow);
+        }
+
+        private static void ValidateWeekWindow(DateOnly weekStart, DateOnly weekEnd)
+        {
+            if (weekEnd < weekStart)
+                throw new ArgumentException("weekEnd must be on or after weekStart.");
+
+            var spanDays = weekEnd.DayNumber - weekStart.DayNumber;
+            if (spanDays > 6)
+                throw new ArgumentException("Week window cannot exceed 7 days.");
+        }
+
+        public static WorkOrderBoardRowDto MapRawRow(WorkOrderBoardRawRow row, DateTime utcNow)
+        {
+            var apptStart = row.ScheduledStart ?? row.DispatchApptDate;
+            var apptEnd = row.ScheduledEnd;
+
+            return new WorkOrderBoardRowDto
+            {
+                Id = row.Id,
+                WoNumber = row.InternalWONumber,
+                RescheduleCount = row.RescheduleCount,
+                CarriedOver = row.CarriedOver,
+                WorkOrderType = row.WorkOrderType,
+                IsPastDue = WorkOrderDerivedFields.IsPastDue(row.ScheduledDate, row.LifecycleStatus, utcNow),
+                SiteCode = row.SiteCode,
+                LocationName = row.LocationName,
+                PocName = row.PocName,
+                PocPhone = row.PocPhone,
+                PocNotes = row.PocNotes,
+                LifecycleStatus = row.LifecycleStatus,
+                LifecycleStatusLabel = WorkOrderDerivedFields.GetLifecycleStatusLabel(row.LifecycleStatus),
+                LegacyStatus = row.LegacyStatus,
+                DispatcherId = row.AssignTo,
+                DispatcherName = FormatName(row.DispatcherFirstName, row.DispatcherLastName),
+                Initials = row.Initials,
+                Color = row.Color,
+                DueDate = row.DueDate,
+                ScheduledDate = row.ScheduledDate,
+                TargetWeek = row.TargetWeek,
+                ScheduleWeekOnly = row.ScheduleWeekOnly,
+                DayGroup = WorkOrderDerivedFields.GetDayGroup(row.ScheduledDate),
+                VendorId = row.VendorId,
+                VendorName = row.VendorName,
+                TechName = row.TechName,
+                TechPhone = row.TechPhone,
+                ApptDate = row.DispatchApptDate ?? row.ScheduledDate,
+                ApptTime = WorkOrderDerivedFields.FormatApptTime(apptStart, apptEnd),
+                Pm = row.Trade ?? row.Problem,
+                ServiceNotes = row.ServiceNotes,
+                ExtraServices = ParseExtraServices(row.ExtraServices),
+                DocStatus = row.DocStatus,
+                FlagColor = row.FlagColor,
+                PrimaryDispatchId = row.PrimaryDispatchId,
+                RowVersion = row.RowVersion,
+                DispatchRowVersion = row.DispatchRowVersion
+            };
+        }
+
+        private static string FormatName(string? firstName, string? lastName)
+            => $"{firstName ?? ""} {lastName ?? ""}".Trim();
+
+        private static List<string>? ParseExtraServices(string? json)
+        {
+            if (string.IsNullOrWhiteSpace(json))
+                return null;
+
+            try
+            {
+                var list = System.Text.Json.JsonSerializer.Deserialize<List<string>>(json);
+                return list is { Count: > 0 } ? list : null;
+            }
+            catch (System.Text.Json.JsonException)
+            {
+                return null;
+            }
+        }
+    }
+}
diff --git a/SeaHaven.Services/Implementation/WorkOrderBoardUpdateService.cs b/SeaHaven.Services/Implementation/WorkOrderBoardUpdateService.cs
new file mode 100644
index 0000000..c924009
--- /dev/null
+++ b/SeaHaven.Services/Implementation/WorkOrderBoardUpdateService.cs
@@ -0,0 +1,640 @@
+using System.Text.Json;
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+using Microsoft.EntityFrameworkCore;
+using SeaHaven.DataServices.Interfaces;
+using SeaHaven.Services.DTOs;
+using SeaHaven.Services.Exceptions;
+using SeaHaven.Services.Helpers;
+using SeaHaven.Services.Interfaces;
+
+namespace SeaHaven.Services.Implementation
+{
+    public class WorkOrderBoardUpdateService : IWorkOrderBoardUpdateService
+    {
+        private readonly ApplicationDbContext _context;
+        private readonly IWorkOrderBoardDataService _boardDataService;
+        private readonly IWorkOrderAuditService _auditService;
+
+        public WorkOrderBoardUpdateService(
+            ApplicationDbContext context,
+            IWorkOrderBoardDataService boardDataService,
+            IWorkOrderAuditService auditService)
+        {
+            _context = context;
+            _boardDataService = boardDataService;
+            _auditService = auditService;
+        }
+
+        public async Task<WorkOrderBoardRowDto> PatchFieldAsync(
+            int workOrderId,
+            WorkOrderBoardPatchRequestDto request,
+            string? actorId)
+        {
+            if (string.IsNullOrWhiteSpace(request.Field))
+                throw new WorkOrderBoardValidationException("InvalidField", "Field is required.");
+
+            var field = request.Field.Trim();
+            var canonicalField = WorkOrderBoardFieldNames.Canonicalize(field);
+            if (canonicalField == null)
+                throw new WorkOrderBoardValidationException("InvalidField", $"Field '{field}' is not editable.");
+
+            var workOrderVersion = ParseRowVersion(request.WorkOrderVersion, "workOrderVersion");
+            if (workOrderVersion == null)
+                throw new WorkOrderBoardValidationException("WorkOrderVersionRequired", "workOrderVersion is required.");
+
+            var dispatchVersion = ParseRowVersion(request.DispatchVersion, "dispatchVersion");
+
+            var workOrder = await _context.workOrders
+                .FirstOrDefaultAsync(w => w.Id == workOrderId && w.istemplate != true && (w.IsDeleted != true || w.IsDeleted == null));
+
+            if (workOrder == null)
+                throw new WorkOrderBoardValidationException("NotFound", "Work order not found.");
+
+            if (!RowVersionsMatch(workOrder.RowVersion, workOrderVersion))
+            {
+                var staleState = await LoadBoardRowAsync(workOrderId);
+                throw new WorkOrderBoardConcurrencyException(staleState);
+            }
+
+            if (WorkOrderBoardMutationRules.IsReadOnly(workOrder.LifecycleStatus))
+                throw new WorkOrderBoardValidationException("CanceledReadOnly", "Work order is read-only in its current status.");
+
+            var isPastDue = WorkOrderDerivedFields.IsPastDue(workOrder.ScheduledDate, workOrder.LifecycleStatus);
+            if (WorkOrderBoardMutationRules.ShouldBlockStatusChangeWhenPastDue(canonicalField, isPastDue))
+                throw new WorkOrderBoardValidationException("PastDueStatusBlocked", "Status cannot be changed while work order is past due. Reschedule first.");
+
+            _context.Entry(workOrder).Property(w => w.RowVersion).OriginalValue = workOrderVersion;
+
+            Dispatch? dispatch = null;
+            if (WorkOrderBoardFieldNames.IsDispatchField(canonicalField))
+            {
+                var vendorIdHint = canonicalField.Equals(WorkOrderBoardFieldNames.VendorId, StringComparison.OrdinalIgnoreCase)
+                    ? ParseVendorIdHint(request.Value)
+                    : null;
+
+                var hadPrimaryDispatch = workOrder.PrimaryDispatchId.HasValue;
+                dispatch = await ResolveDispatchAsync(workOrder, request.PrimaryDispatchId, vendorIdHint);
+
+                if (dispatchVersion != null && !RowVersionsMatch(dispatch.RowVersion, dispatchVersion))
+                {
+                    var staleState = await LoadBoardRowAsync(workOrderId);
+                    throw new WorkOrderBoardConcurrencyException(staleState);
+                }
+
+                if (dispatchVersion != null)
+                    _context.Entry(dispatch).Property(d => d.RowVersion).OriginalValue = dispatchVersion;
+                else if (hadPrimaryDispatch && dispatch.RowVersion != null)
+                    throw new WorkOrderBoardValidationException("DispatchVersionRequired", "dispatchVersion is required for dispatch fields.");
+            }
+
+            var auditField = WorkOrderBoardFieldNames.ToAuditFieldName(canonicalField);
+            var changes = await ApplyFieldMutationAsync(canonicalField, workOrder, dispatch, request.Value, auditField);
+            changes = changes.Where(c => c.HasChanged).ToList();
+
+            if (changes.Count == 0 && !_context.ChangeTracker.HasChanges())
+            {
+                var unchanged = await LoadBoardRowAsync(workOrderId);
+                return unchanged ?? throw new WorkOrderBoardValidationException("NotFound", "Work order not found.");
+            }
+
+            if (changes.Count == 0)
+            {
+                await _context.SaveChangesAsync();
+                var persisted = await LoadBoardRowAsync(workOrderId);
+                return persisted ?? throw new WorkOrderBoardValidationException("NotFound", "Work order not found.");
+            }
+
+            foreach (var change in changes)
+            {
+                switch (change.Action)
+                {
+                    case AuditActionType.StatusChanged:
+                        _auditService.StageStatusChanged(workOrderId, change.OldValue, change.NewValue, actorId);
+                        break;
+                    case AuditActionType.AssignmentChanged:
+                        _auditService.StageAssignmentChanged(workOrderId, change.OldValue, change.NewValue, actorId);
+                        break;
+                    default:
+                        _auditService.StageFieldChanged(workOrderId, change.FieldName, change.OldValue, change.NewValue, actorId, change.DispatchId);
+                        break;
+                }
+            }
+
+            try
+            {
+                await _context.SaveChangesAsync();
+            }
+            catch (DbUpdateConcurrencyException)
+            {
+                _context.ChangeTracker.Clear();
+                var currentState = await LoadBoardRowAsync(workOrderId);
+                throw new WorkOrderBoardConcurrencyException(currentState);
+            }
+
+            var row = await LoadBoardRowAsync(workOrderId);
+            return row ?? throw new WorkOrderBoardValidationException("NotFound", "Work order not found.");
+        }
+
+        private async Task<List<FieldChange>> ApplyFieldMutationAsync(
+            string field,
+            WorkOrder workOrder,
+            Dispatch? dispatch,
+            string? value,
+            string auditField)
+        {
+            return field switch
+            {
+                WorkOrderBoardFieldNames.WoNumber => new List<FieldChange> { await ApplyWoNumber(workOrder, value, auditField) },
+                WorkOrderBoardFieldNames.WorkOrderType => new List<FieldChange> { ApplyWorkOrderType(workOrder, value, auditField) },
+                WorkOrderBoardFieldNames.SiteCode => new List<FieldChange> { ApplyStringField(value, auditField, v => workOrder.SiteCode = v, () => workOrder.SiteCode) },
+                WorkOrderBoardFieldNames.LifecycleStatus => new List<FieldChange> { ApplyLifecycleStatus(workOrder, value, auditField) },
+                WorkOrderBoardFieldNames.AssignTo => ApplyAssignTo(workOrder, value, auditField),
+                WorkOrderBoardFieldNames.DueDate => new List<FieldChange> { ApplyDateField(value, auditField, v => workOrder.DueDate = v, () => workOrder.DueDate) },
+                WorkOrderBoardFieldNames.ScheduledDate => ApplyScheduledDate(workOrder, value, auditField),
+                WorkOrderBoardFieldNames.TargetWeek => new List<FieldChange> { ApplyTargetWeek(workOrder, value, auditField) },
+                WorkOrderBoardFieldNames.ScheduleWeekOnly => new List<FieldChange> { ApplyBoolField(value, auditField, v => workOrder.ScheduleWeekOnly = v, () => workOrder.ScheduleWeekOnly) },
+                WorkOrderBoardFieldNames.VendorId => new List<FieldChange> { ApplyVendorId(dispatch!, value, auditField) },
+                WorkOrderBoardFieldNames.ApptDate => new List<FieldChange> { ApplyApptDate(dispatch!, value, auditField) },
+                WorkOrderBoardFieldNames.ApptTime => new List<FieldChange> { ApplyApptTime(workOrder, dispatch!, value, auditField) },
+                WorkOrderBoardFieldNames.DocStatus => new List<FieldChange> { ApplyDocStatus(workOrder, value, auditField) },
+                WorkOrderBoardFieldNames.Pm => new List<FieldChange> { ApplyStringField(value, auditField, v => workOrder.Trade = v, () => workOrder.Trade) },
+                WorkOrderBoardFieldNames.ServiceNotes => new List<FieldChange> { ApplyServiceNotes(workOrder, value, auditField) },
+                WorkOrderBoardFieldNames.ExtraServices => new List<FieldChange> { ApplyExtraServices(workOrder, value, auditField) },
+                WorkOrderBoardFieldNames.FlagColor => new List<FieldChange> { ApplyFlagColor(workOrder, value, auditField) },
+                _ => throw new WorkOrderBoardValidationException("InvalidField", $"Field '{field}' is not editable.")
+            };
+        }
+
+        private async Task<Dispatch> ResolveDispatchAsync(WorkOrder workOrder, int? primaryDispatchId, int? vendorIdForCreate)
+        {
+            if (primaryDispatchId.HasValue)
+            {
+                var dispatch = await _context.Dispatches
+                    .FirstOrDefaultAsync(d => d.Id == primaryDispatchId.Value && d.WorkOrderId == workOrder.Id);
+
+                if (dispatch == null)
+                    throw new WorkOrderBoardValidationException("InvalidDispatch", "Primary dispatch does not belong to this work order.");
+
+                workOrder.PrimaryDispatchId = dispatch.Id;
+                return dispatch;
+            }
+
+            if (workOrder.PrimaryDispatchId.HasValue)
+            {
+                var existing = await _context.Dispatches
+                    .FirstOrDefaultAsync(d => d.Id == workOrder.PrimaryDispatchId.Value);
+
+                if (existing != null)
+                    return existing;
+            }
+
+            if (!vendorIdForCreate.HasValue || vendorIdForCreate.Value <= 0)
+                throw new WorkOrderBoardValidationException("DispatchRequired", "A primary dispatch is required. Set vendorId first or provide primaryDispatchId.");
+
+            var created = new Dispatch
+            {
+                WorkOrderId = workOrder.Id,
+                VendorId = vendorIdForCreate.Value,
+                Status = "Pending",
+                CreatedDate = DateTime.UtcNow
+            };
+            _context.Dispatches.Add(created);
+            await _context.SaveChangesAsync();
+            workOrder.PrimaryDispatchId = created.Id;
+            return created;
+        }
+
+        private async Task<FieldChange> ApplyWoNumber(WorkOrder workOrder, string? value, string auditField)
+        {
+            if (!WorkOrderNumberNormalizer.TryNormalize(value, out var normalized, out var error))
+                throw new WorkOrderBoardValidationException("InvalidWoNumber", error ?? "Invalid WO number.");
+
+            if (await _boardDataService.InternalWoNumberExistsAsync(normalized, workOrder.Id))
+                throw new WorkOrderBoardValidationException("DuplicateWoNumber", "WO number already exists.");
+
+            var old = workOrder.InternalWONumber;
+            if (old == normalized)
+                return FieldChange.Unchanged(auditField);
+
+            workOrder.InternalWONumber = normalized;
+            workOrder.WorkerOrderNumber = normalized;
+            return FieldChange.ForField(auditField, old, normalized);
+        }
+
+        private static FieldChange ApplyWorkOrderType(WorkOrder workOrder, string? value, string auditField)
+        {
+            if (string.IsNullOrWhiteSpace(value))
+                throw new WorkOrderBoardValidationException("InvalidValue", "workOrderType value is required.");
+
+            if (string.Equals(value.Trim(), "Overdue", StringComparison.OrdinalIgnoreCase))
+                throw new WorkOrderBoardValidationException(
+                    "InvalidValue",
+                    "Overdue is not a work order type; it is derived from scheduledDate (isPastDue).");
+
+            if (!WorkOrderTypeMapper.TryParseFeLabel(value, out var parsed))
+                throw new WorkOrderBoardValidationException("InvalidValue", $"Invalid workOrderType: {value}");
+
+            var old = workOrder.WorkOrderType?.ToString();
+            if (workOrder.WorkOrderType == parsed)
+                return FieldChange.Unchanged(auditField);
+
+            workOrder.WorkOrderType = parsed;
+            return FieldChange.ForField(auditField, old, parsed.ToString());
+        }
+
+        private static FieldChange ApplyStringField(
+            string? value,
+            string auditField,
+            Action<string?> setter,
+            Func<string?> getter)
+        {
+            var normalized = string.IsNullOrWhiteSpace(value) ? null : value.Trim();
+            var old = getter();
+            if (old == normalized)
+                return FieldChange.Unchanged(auditField);
+
+            setter(normalized);
+            return FieldChange.ForField(auditField, old, normalized);
+        }
+
+        private static FieldChange ApplyServiceNotes(WorkOrder workOrder, string? value, string auditField)
+        {
+            var normalized = string.IsNullOrWhiteSpace(value) ? null : value.Trim();
+            if (normalized != null && normalized.Length > 4000)
+                throw new WorkOrderBoardValidationException("InvalidValue", "serviceNotes must be at most 4000 characters.");
+
+            var old = workOrder.ServiceNotes;
+            if (old == normalized)
+                return FieldChange.Unchanged(auditField);
+
+            workOrder.ServiceNotes = normalized;
+            return FieldChange.ForField(auditField, old, normalized);
+        }
+
+        private static FieldChange ApplyExtraServices(WorkOrder workOrder, string? value, string auditField)
+        {
+            string? normalizedJson = null;
+            if (!string.IsNullOrWhiteSpace(value))
+            {
+                List<string>? parsed;
+                try
+                {
+                    parsed = JsonSerializer.Deserialize<List<string>>(value.Trim());
+                }
+                catch (JsonException)
+                {
+                    throw new WorkOrderBoardValidationException("InvalidValue", "extraServices must be a JSON string array.");
+                }
+
+                var items = NormalizeExtraServiceList(parsed);
+                if (items.Count > 0)
+                {
+                    if (string.IsNullOrWhiteSpace(workOrder.Trade))
+                    {
+                        throw new WorkOrderBoardValidationException(
+                            "InvalidValue",
+                            "primaryService (pm/trade) is required when extraServices is provided.");
+                    }
+
+                    items = items
+                        .Where(s => !string.Equals(s, workOrder.Trade, StringComparison.OrdinalIgnoreCase))
+                        .ToList();
+
+                    normalizedJson = items.Count > 0 ? JsonSerializer.Serialize(items) : null;
+                    if (normalizedJson != null && normalizedJson.Length > 2000)
+                    {
+                        throw new WorkOrderBoardValidationException(
+                            "InvalidValue",
+                            "extraServices must serialize to at most 2000 characters.");
+                    }
+                }
+            }
+
+            var old = workOrder.ExtraServices;
+            if (old == normalizedJson)
+                return FieldChange.Unchanged(auditField);
+
+            workOrder.ExtraServices = normalizedJson;
+            return FieldChange.ForField(auditField, old, normalizedJson);
+        }
+
+        private static List<string> NormalizeExtraServiceList(List<string>? extras)
+        {
+            var normalized = new List<string>();
+            if (extras == null || extras.Count == 0)
+                return normalized;
+
+            var seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+            foreach (var item in extras)
+            {
+                if (string.IsNullOrWhiteSpace(item))
+                    continue;
+                var trimmed = item.Trim();
+                if (trimmed.Length > 128)
+                    throw new WorkOrderBoardValidationException("InvalidValue", "Each extra service must be at most 128 characters.");
+                if (!seen.Add(trimmed))
+                    continue;
+                normalized.Add(trimmed);
+            }
+
+            return normalized;
+        }
+
+        private static FieldChange ApplyLifecycleStatus(WorkOrder workOrder, string? value, string auditField)
+        {
+            var parsed = LifecycleStatusMapper.ParseLifecycleStatus(value);
+            if (parsed == null)
+                throw new WorkOrderBoardValidationException("InvalidValue", $"Invalid lifecycleStatus: {value}");
+
+            var old = workOrder.LifecycleStatus?.ToString() ?? workOrder.Status;
+            if (workOrder.LifecycleStatus == parsed)
+                return FieldChange.Unchanged(auditField);
+
+            workOrder.LifecycleStatus = parsed;
+            workOrder.Status = WorkOrderDerivedFields.GetLifecycleStatusLabel(parsed);
+            if (workOrder.LegacyStatus == null && workOrder.Status != null)
+                workOrder.LegacyStatus = workOrder.Status;
+
+            return FieldChange.StatusChanged(auditField, old, parsed.ToString());
+        }
+
+        private static List<FieldChange> ApplyAssignTo(WorkOrder workOrder, string? value, string auditField)
+        {
+            var normalized = string.IsNullOrWhiteSpace(value) ? null : value.Trim();
+            var old = workOrder.AssignTo;
+            var changes = new List<FieldChange>();
+
+            if (old != normalized)
+            {
+                workOrder.AssignTo = normalized;
+                changes.Add(FieldChange.AssignmentChanged(auditField, old, normalized));
+            }
+
+            changes.AddRange(ApplyAutoScheduleSideEffects(workOrder));
+            return changes;
+        }
+
+        private static FieldChange ApplyDateField(
+            string? value,
+            string auditField,
+            Action<DateTime?> setter,
+            Func<DateTime?> getter)
+        {
+            DateTime? parsed = null;
+            if (!string.IsNullOrWhiteSpace(value))
+            {
+                if (!DateTime.TryParse(value, out var dt))
+                    throw new WorkOrderBoardValidationException("InvalidValue", $"Invalid date for {auditField}: {value}");
+                parsed = dt.Date;
+            }
+
+            var old = FormatDate(getter());
+            var newVal = FormatDate(parsed);
+            if (old == newVal)
+                return FieldChange.Unchanged(auditField);
+
+            setter(parsed);
+            return FieldChange.ForField(auditField, old, newVal);
+        }
+
+        private static List<FieldChange> ApplyScheduledDate(WorkOrder workOrder, string? value, string auditField)
+        {
+            var previousDate = workOrder.ScheduledDate;
+            DateTime? parsed = null;
+            if (!string.IsNullOrWhiteSpace(value))
+            {
+                if (!DateTime.TryParse(value, out var dt))
+                    throw new WorkOrderBoardValidationException("InvalidValue", $"Invalid scheduledDate: {value}");
+                parsed = dt.Date;
+            }
+
+            var changes = new List<FieldChange>();
+            var oldFormatted = FormatDate(previousDate);
+            var newFormatted = FormatDate(parsed);
+
+            if (oldFormatted != newFormatted)
+            {
+                workOrder.ScheduledDate = parsed;
+                changes.Add(FieldChange.ForField(auditField, oldFormatted, newFormatted));
+
+                if (!workOrder.OriginalDate.HasValue && parsed.HasValue)
+                {
+                    workOrder.OriginalDate = DateOnly.FromDateTime(parsed.Value);
+                    var originalWeek = WorkOrderBoardMutationRules.ComputeOriginalWeek(parsed);
+                    if (originalWeek.HasValue)
+                        workOrder.OriginalWeek = originalWeek;
+                }
+
+                if (WorkOrderBoardMutationRules.IsReschedule(previousDate, parsed))
+                {
+                    var oldCount = workOrder.RescheduleCount.ToString();
+                    workOrder.RescheduleCount++;
+                    changes.Add(FieldChange.ForField(WorkOrderBoardFieldNames.RescheduleCount, oldCount, workOrder.RescheduleCount.ToString()));
+                }
+            }
+
+            changes.AddRange(ApplyAutoScheduleSideEffects(workOrder));
+            return changes;
+        }
+
+        private static FieldChange ApplyTargetWeek(WorkOrder workOrder, string? value, string auditField)
+        {
+            DateOnly? parsed = null;
+            if (!string.IsNullOrWhiteSpace(value))
+            {
+                if (!DateOnly.TryParse(value, out var d))
+                    throw new WorkOrderBoardValidationException("InvalidValue", $"Invalid targetWeek: {value}");
+                parsed = d;
+            }
+
+            var old = workOrder.TargetWeek?.ToString("yyyy-MM-dd");
+            var newVal = parsed?.ToString("yyyy-MM-dd");
+            if (old == newVal)
+                return FieldChange.Unchanged(auditField);
+
+            workOrder.TargetWeek = parsed;
+            return FieldChange.ForField(auditField, old, newVal);
+        }
+
+        private static FieldChange ApplyBoolField(
+            string? value,
+            string auditField,
+            Action<bool?> setter,
+            Func<bool?> getter)
+        {
+            if (string.IsNullOrWhiteSpace(value))
+                throw new WorkOrderBoardValidationException("InvalidValue", $"{auditField} value is required.");
+
+            if (!bool.TryParse(value, out var parsed))
+                throw new WorkOrderBoardValidationException("InvalidValue", $"Invalid boolean for {auditField}: {value}");
+
+            var old = getter()?.ToString();
+            if (getter() == parsed)
+                return FieldChange.Unchanged(auditField);
+
+            setter(parsed);
+            return FieldChange.ForField(auditField, old, parsed.ToString());
+        }
+
+        private static FieldChange ApplyVendorId(Dispatch dispatch, string? value, string auditField)
+        {
+            var vendorId = ParseVendorIdHint(value);
+            if (!vendorId.HasValue)
+                throw new WorkOrderBoardValidationException("InvalidValue", "vendorId must be a positive integer.");
+
+            var old = dispatch.VendorId.ToString();
+            if (dispatch.VendorId == vendorId.Value)
+                return FieldChange.Unchanged(auditField, dispatch.Id);
+
+            dispatch.VendorId = vendorId.Value;
+            return FieldChange.ForField(auditField, old, vendorId.Value.ToString(), dispatch.Id);
+        }
+
+        private static FieldChange ApplyApptDate(Dispatch dispatch, string? value, string auditField)
+        {
+            DateTime? parsed = null;
+            if (!string.IsNullOrWhiteSpace(value))
+            {
+                if (!DateTime.TryParse(value, out var dt))
+                    throw new WorkOrderBoardValidationException("InvalidValue", $"Invalid apptDate: {value}");
+                parsed = dt.Date;
+            }
+
+            var old = FormatDate(dispatch.ScheduledDate);
+            var newVal = FormatDate(parsed);
+            if (old == newVal)
+                return FieldChange.Unchanged(auditField, dispatch.Id);
+
+            dispatch.ScheduledDate = parsed;
+            return FieldChange.ForField(auditField, old, newVal, dispatch.Id);
+        }
+
+        private static FieldChange ApplyApptTime(WorkOrder workOrder, Dispatch dispatch, string? value, string auditField)
+        {
+            if (!WorkOrderBoardApptTimeParser.TryParse(value, out var start, out var end, out var error))
+                throw new WorkOrderBoardValidationException("InvalidValue", error ?? "Invalid apptTime.");
+
+            var apptDate = dispatch.ScheduledDate ?? workOrder.ScheduledDate;
+            var oldStart = FormatDateTime(workOrder.ScheduledStart);
+            var oldEnd = FormatDateTime(workOrder.ScheduledEnd);
+
+            workOrder.ScheduledStart = WorkOrderBoardApptTimeParser.CombineDateAndTime(apptDate, start);
+            workOrder.ScheduledEnd = WorkOrderBoardApptTimeParser.CombineDateAndTime(apptDate, end);
+
+            var newStart = FormatDateTime(workOrder.ScheduledStart);
+            var newEnd = FormatDateTime(workOrder.ScheduledEnd);
+            var oldCombined = FormatApptRange(oldStart, oldEnd);
+            var newCombined = FormatApptRange(newStart, newEnd);
+
+            if (oldCombined == newCombined)
+                return FieldChange.Unchanged(auditField, dispatch.Id);
+
+            return FieldChange.ForField(auditField, oldCombined, newCombined, dispatch.Id);
+        }
+
+        private static FieldChange ApplyDocStatus(WorkOrder workOrder, string? value, string auditField)
+        {
+            if (string.IsNullOrWhiteSpace(value))
+                throw new WorkOrderBoardValidationException("InvalidValue", "docStatus value is required.");
+
+            if (!Enum.TryParse<DocStatus>(value, true, out var parsed))
+                throw new WorkOrderBoardValidationException("InvalidValue", $"Invalid docStatus: {value}");
+
+            var old = workOrder.DocStatus?.ToString();
+            if (workOrder.DocStatus == parsed)
+                return FieldChange.Unchanged(auditField);
+
+            workOrder.DocStatus = parsed;
+            return FieldChange.ForField(auditField, old, parsed.ToString());
+        }
+
+        private static FieldChange ApplyFlagColor(WorkOrder workOrder, string? value, string auditField)
+        {
+            if (!WorkOrderFlagColors.TryNormalize(value, out var canonical))
+                throw new WorkOrderBoardValidationException("InvalidValue", $"Invalid flagColor: {value}");
+
+            if (canonical != null && !WorkOrderFlagColors.IsAllowed(canonical))
+                throw new WorkOrderBoardValidationException(
+                    "InvalidValue",
+                    $"flagColor must be one of the allowed palette values or empty to clear.");
+
+            var old = workOrder.FlagColor;
+            if (string.Equals(old, canonical, StringComparison.OrdinalIgnoreCase))
+                return FieldChange.Unchanged(auditField);
+
+            workOrder.FlagColor = canonical;
+            return FieldChange.ForField(auditField, old, canonical);
+        }
+
+        private static List<FieldChange> ApplyAutoScheduleSideEffects(WorkOrder workOrder)
+        {
+            var changes = new List<FieldChange>();
+            if (!WorkOrderBoardMutationRules.ShouldAutoSchedule(workOrder.LifecycleStatus, workOrder.ScheduledDate, workOrder.AssignTo))
+                return changes;
+
+            var old = workOrder.LifecycleStatus?.ToString();
+            workOrder.LifecycleStatus = LifecycleStatus.Scheduled;
+            workOrder.Status = WorkOrderDerivedFields.GetLifecycleStatusLabel(LifecycleStatus.Scheduled);
+            changes.Add(FieldChange.StatusChanged("LifecycleStatus", old, LifecycleStatus.Scheduled.ToString()));
+            return changes;
+        }
+
+        private static bool RowVersionsMatch(byte[]? current, byte[] expected)
+            => current != null && current.AsSpan().SequenceEqual(expected);
+
+        private async Task<WorkOrderBoardRowDto?> LoadBoardRowAsync(int workOrderId)
+        {
+            var raw = await _boardDataService.GetBoardRowByIdAsync(workOrderId);
+            return raw == null ? null : WorkOrderBoardService.MapRawRow(raw, DateTime.UtcNow);
+        }
+
+        private static byte[]? ParseRowVersion(string? base64, string fieldName)
+        {
+            if (string.IsNullOrWhiteSpace(base64))
+                return null;
+
+            try
+            {
+                return Convert.FromBase64String(base64);
+            }
+            catch (FormatException)
+            {
+                throw new WorkOrderBoardValidationException("InvalidRowVersion", $"Invalid {fieldName} format.");
+            }
+        }
+
+        private static int? ParseVendorIdHint(string? value)
+        {
+            if (string.IsNullOrWhiteSpace(value) || !int.TryParse(value, out var vendorId) || vendorId <= 0)
+                return null;
+            return vendorId;
+        }
+
+        private static string? FormatDate(DateTime? value) => value?.ToString("yyyy-MM-dd");
+        private static string? FormatDateTime(DateTime? value) => value?.ToString("O");
+        private static string? FormatApptRange(string? start, string? end)
+            => start == null && end == null ? null : $"{start}|{end}";
+
+        private sealed record FieldChange(
+            string FieldName,
+            string? OldValue,
+            string? NewValue,
+            AuditActionType Action,
+            int? DispatchId,
+            bool HasChanged)
+        {
+            public static FieldChange Unchanged(string fieldName, int? dispatchId = null)
+                => new(fieldName, null, null, AuditActionType.FieldChanged, dispatchId, false);
+
+            public static FieldChange ForField(string fieldName, string? oldValue, string? newValue, int? dispatchId = null)
+                => new(fieldName, oldValue, newValue, AuditActionType.FieldChanged, dispatchId, true);
+
+            public static FieldChange StatusChanged(string fieldName, string? oldValue, string? newValue)
+                => new(fieldName, oldValue, newValue, AuditActionType.StatusChanged, null, true);
+
+            public static FieldChange AssignmentChanged(string fieldName, string? oldValue, string? newValue)
+                => new(fieldName, oldValue, newValue, AuditActionType.AssignmentChanged, null, true);
+        }
+    }
+}
diff --git a/SeaHaven.Services/Implementation/WorkOrderCommentService.cs b/SeaHaven.Services/Implementation/WorkOrderCommentService.cs
new file mode 100644
index 0000000..da0098d
--- /dev/null
+++ b/SeaHaven.Services/Implementation/WorkOrderCommentService.cs
@@ -0,0 +1,114 @@
+using Data.SeaHavenIndustries;
+using SeaHaven.DataServices.Interfaces;
+using SeaHaven.Services.DTOs;
+using SeaHaven.Services.Exceptions;
+using SeaHaven.Services.Helpers;
+using SeaHaven.Services.Interfaces;
+
+namespace SeaHaven.Services.Implementation
+{
+    public class WorkOrderCommentService : IWorkOrderCommentService
+    {
+        private readonly IWorkOrderDetailDataService _detailData;
+        private readonly ICommentDataService _commentData;
+        private readonly IUserDataService _userDataService;
+
+        public WorkOrderCommentService(
+            IWorkOrderDetailDataService detailData,
+            ICommentDataService commentData,
+            IUserDataService userDataService)
+        {
+            _detailData = detailData;
+            _commentData = commentData;
+            _userDataService = userDataService;
+        }
+
+        public async Task<IReadOnlyList<WorkOrderCommentDto>?> GetCommentsAsync(int workOrderId)
+        {
+            if (!await _detailData.ExistsAsync(workOrderId))
+                return null;
+
+            var comments = await _detailData.GetCommentsAsync(workOrderId);
+            var authorNames = await ResolveAuthorNamesAsync(comments);
+            return WorkOrderCommentProjection.ToDtos(comments, authorNames);
+        }
+
+        public async Task<WorkOrderCommentDto> AddCommentAsync(
+            int workOrderId,
+            WorkOrderCommentCreateDto request,
+            string? actorId,
+            string? documentUrl = null)
+        {
+            if (!await _detailData.ExistsAsync(workOrderId))
+                throw new WorkOrderBoardValidationException("NotFound", "Work order not found.");
+
+            if (string.IsNullOrWhiteSpace(request.Text))
+                throw new WorkOrderBoardValidationException("InvalidValue", "Comment text is required.");
+
+            var comment = new Comments
+            {
+                WorkerOrderId = workOrderId,
+                UserId = actorId,
+                Commenttext = request.Text.Trim(),
+                CommentType = "General",
+                RecordType = "WorkOrder",
+                Documents = documentUrl,
+                CreatedDate = DateTime.UtcNow
+            };
+
+            var saved = await _commentData.AddAsync(comment);
+            var authorNames = await ResolveAuthorNamesAsync(new[] { saved });
+            return WorkOrderCommentProjection.ToDto(saved, authorNames);
+        }
+
+        public async Task<WorkOrderCommentDto> UpdateCommentAsync(
+            int workOrderId,
+            int commentId,
+            WorkOrderCommentCreateDto request,
+            string? actorId,
+            bool isAdmin)
+        {
+            var workOrder = await _detailData.GetWorkOrderForMediaAsync(workOrderId);
+            if (workOrder == null)
+                throw new WorkOrderBoardValidationException("NotFound", "Work order not found.");
+
+            if (WorkOrderBoardMutationRules.IsReadOnly(workOrder.LifecycleStatus))
+                throw new WorkOrderBoardValidationException("ReadOnly", "Work order is read-only in its current status.");
+
+            if (string.IsNullOrWhiteSpace(request.Text))
+                throw new WorkOrderBoardValidationException("InvalidValue", "Comment text is required.");
+
+            var comment = await _commentData.GetByIdAsync(commentId);
+            if (comment == null || comment.WorkerOrderId != workOrderId || comment.IsDeleted == true)
+                throw new WorkOrderBoardValidationException("NotFound", "Comment not found.");
+
+            if (!IsBoardEditableComment(comment))
+                throw new WorkOrderBoardValidationException(
+                    "NotEditable",
+                    "Only board comments (CommentType General) can be edited via this endpoint.");
+
+            var isAuthor = !string.IsNullOrWhiteSpace(actorId)
+                && string.Equals(comment.UserId, actorId, StringComparison.Ordinal);
+            if (!isAuthor && !isAdmin)
+                throw new WorkOrderBoardValidationException("Forbidden", "You are not allowed to edit this comment.");
+
+            comment.Commenttext = request.Text.Trim();
+            comment.LastModificationTime = DateTime.UtcNow;
+            await _commentData.UpdateAsync(comment);
+
+            var authorNames = await ResolveAuthorNamesAsync(new[] { comment });
+            return WorkOrderCommentProjection.ToDto(comment, authorNames);
+        }
+
+        private static bool IsBoardEditableComment(Comments comment)
+            => string.Equals(comment.CommentType, "General", StringComparison.OrdinalIgnoreCase)
+               && string.Equals(comment.RecordType, "WorkOrder", StringComparison.OrdinalIgnoreCase);
+
+        private async Task<IReadOnlyDictionary<string, string>> ResolveAuthorNamesAsync(
+            IEnumerable<Comments> comments)
+        {
+            var authorIds = WorkOrderCommentProjection.CollectAuthorUserIds(comments);
+            return await _userDataService.GetDisplayNamesByIdsAsync(authorIds);
+        }
+    }
+}
diff --git a/SeaHaven.Services/Implementation/WorkOrderCompletionService.cs b/SeaHaven.Services/Implementation/WorkOrderCompletionService.cs
new file mode 100644
index 0000000..ccea868
--- /dev/null
+++ b/SeaHaven.Services/Implementation/WorkOrderCompletionService.cs
@@ -0,0 +1,178 @@
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+using Microsoft.EntityFrameworkCore;
+using SeaHaven.DataServices.Interfaces;
+using SeaHaven.Services.DTOs;
+using SeaHaven.Services.Exceptions;
+using SeaHaven.Services.Helpers;
+using SeaHaven.Services.Interfaces;
+
+namespace SeaHaven.Services.Implementation
+{
+    public class WorkOrderCompletionService : IWorkOrderCompletionService
+    {
+        private readonly ApplicationDbContext _context;
+        private readonly ICompletionDocTemplateDataService _templateData;
+        private readonly IWorkOrderDetailDataService _detailData;
+        private readonly IWorkOrderAuditService _auditService;
+
+        public WorkOrderCompletionService(
+            ApplicationDbContext context,
+            ICompletionDocTemplateDataService templateData,
+            IWorkOrderDetailDataService detailData,
+            IWorkOrderAuditService auditService)
+        {
+            _context = context;
+            _templateData = templateData;
+            _detailData = detailData;
+            _auditService = auditService;
+        }
+
+        public async Task<IReadOnlyList<CompletionDocTemplateDto>> GetTemplatesAsync(string? serviceKey, WorkOrderType? workOrderType)
+        {
+            var rows = await _templateData.GetActiveAsync(serviceKey, workOrderType);
+            return rows.Select(WorkOrderDetailService.MapTemplate).ToList();
+        }
+
+        public async Task<CompletionDocTemplateDto?> GetTemplateByIdAsync(int id)
+        {
+            var row = await _templateData.GetByIdAsync(id);
+            return row == null ? null : WorkOrderDetailService.MapTemplate(row);
+        }
+
+        public async Task<WorkOrderCompletionDto> UploadCompletionDocAsync(
+            int workOrderId,
+            WorkOrderCompletionDocUploadDto request,
+            string fileUrl,
+            string? actorId)
+        {
+            var workOrder = await _context.workOrders
+                .FirstOrDefaultAsync(w => w.Id == workOrderId && w.istemplate != true && (w.IsDeleted != true || w.IsDeleted == null));
+
+            if (workOrder == null)
+                throw new WorkOrderBoardValidationException("NotFound", "Work order not found.");
+
+            if (WorkOrderBoardMutationRules.IsReadOnly(workOrder.LifecycleStatus))
+                throw new WorkOrderBoardValidationException("ReadOnly", "Work order is read-only in its current status.");
+
+            var workOrderVersion = ParseRowVersion(request.WorkOrderVersion);
+            if (workOrderVersion == null)
+                throw new WorkOrderBoardValidationException("WorkOrderVersionRequired", "workOrderVersion is required.");
+
+            if (workOrder.RowVersion == null || !workOrder.RowVersion.AsSpan().SequenceEqual(workOrderVersion))
+                throw new WorkOrderBoardValidationException("ConcurrencyConflict", "Work order was modified. Refresh and retry.");
+
+            _context.Entry(workOrder).Property(w => w.RowVersion).OriginalValue = workOrderVersion;
+
+            var oldDocStatus = workOrder.DocStatus?.ToString();
+            var oldAttachment = workOrder.SignOffAttachment;
+
+            workOrder.SignOffAttachment = fileUrl;
+            if (!string.IsNullOrWhiteSpace(request.SignOffName))
+                workOrder.SignOffName = request.SignOffName.Trim();
+            if (!string.IsNullOrWhiteSpace(request.SignOffSignature))
+                workOrder.SignOffSignature = request.SignOffSignature.Trim();
+
+            workOrder.DocStatus = DocStatus.Yes;
+
+            _auditService.StageFieldChanged(workOrderId, "SignOffAttachment", oldAttachment, fileUrl, actorId);
+            if (oldDocStatus != DocStatus.Yes.ToString())
+                _auditService.StageFieldChanged(workOrderId, "DocStatus", oldDocStatus, DocStatus.Yes.ToString(), actorId);
+
+            await _context.SaveChangesAsync();
+
+            var extended = await _detailData.GetExtendedFieldsAsync(workOrderId);
+            var template = await _templateData.ResolveForWorkOrderAsync(workOrder.Trade, workOrder.WorkOrderType);
+            var signoffs = await _detailData.GetDispatchSignoffsAsync(workOrderId);
+
+            return new WorkOrderCompletionDto
+            {
+                DocStatus = workOrder.DocStatus,
+                Template = template == null ? null : WorkOrderDetailService.MapTemplate(template),
+                SignOffName = extended?.SignOffName,
+                SignOffAttachment = extended?.SignOffAttachment,
+                SignOffSignature = extended?.SignOffSignature,
+                DispatchSignoffs = signoffs.Select(s => new DispatchSignoffDto
+                {
+                    DispatchId = s.DispatchId,
+                    SignoffType = s.SignoffType,
+                    Name = s.Name,
+                    SignedAt = s.SignedAt?.ToUniversalTime().ToString("o")
+                }).ToList()
+            };
+        }
+
+        public async Task<CompletionDocTemplateDto> CreateTemplateAsync(CompletionDocTemplateCreateDto request)
+        {
+            ValidateTemplateRequest(request);
+
+            var entity = new CompletionDocTemplate
+            {
+                Name = request.Name.Trim(),
+                ServiceKey = request.ServiceKey.Trim(),
+                WorkOrderType = request.WorkOrderType,
+                TemplateUrl = request.TemplateUrl.Trim(),
+                IsActive = request.IsActive
+            };
+
+            var created = await _templateData.CreateAsync(entity);
+            return WorkOrderDetailService.MapTemplate(new CompletionDocTemplateRow(
+                created.Id, created.Name, created.ServiceKey, created.WorkOrderType, created.TemplateUrl, created.IsActive));
+        }
+
+        public async Task<CompletionDocTemplateDto> UpdateTemplateAsync(int id, CompletionDocTemplateCreateDto request)
+        {
+            ValidateTemplateRequest(request);
+
+            var entity = await _context.CompletionDocTemplates.FirstOrDefaultAsync(t => t.Id == id && t.IsDeleted != true);
+            if (entity == null)
+                throw new WorkOrderBoardValidationException("NotFound", "Template not found.");
+
+            entity.Name = request.Name.Trim();
+            entity.ServiceKey = request.ServiceKey.Trim();
+            entity.WorkOrderType = request.WorkOrderType;
+            entity.TemplateUrl = request.TemplateUrl.Trim();
+            entity.IsActive = request.IsActive;
+
+            await _templateData.UpdateAsync(entity);
+            return WorkOrderDetailService.MapTemplate(new CompletionDocTemplateRow(
+                entity.Id, entity.Name, entity.ServiceKey, entity.WorkOrderType, entity.TemplateUrl, entity.IsActive));
+        }
+
+        public async Task DeleteTemplateAsync(int id)
+        {
+            if (!await _templateData.DeleteAsync(id))
+                throw new WorkOrderBoardValidationException("NotFound", "Template not found.");
+        }
+
+        private static void ValidateTemplateRequest(CompletionDocTemplateCreateDto request)
+        {
+            if (string.IsNullOrWhiteSpace(request.Name) || string.IsNullOrWhiteSpace(request.ServiceKey))
+                throw new WorkOrderBoardValidationException("InvalidValue", "Name and serviceKey are required.");
+
+            if (string.IsNullOrWhiteSpace(request.TemplateUrl))
+                throw new WorkOrderBoardValidationException("InvalidValue", "TemplateUrl is required.");
+
+            if (!Uri.TryCreate(request.TemplateUrl.Trim(), UriKind.Absolute, out var uri)
+                || (uri.Scheme != Uri.UriSchemeHttp && uri.Scheme != Uri.UriSchemeHttps))
+            {
+                throw new WorkOrderBoardValidationException("InvalidValue", "TemplateUrl must be an absolute http(s) URL.");
+            }
+        }
+
+        private static byte[]? ParseRowVersion(string? base64)
+        {
+            if (string.IsNullOrWhiteSpace(base64))
+                return null;
+
+            try
+            {
+                return Convert.FromBase64String(base64);
+            }
+            catch (FormatException)
+            {
+                throw new WorkOrderBoardValidationException("InvalidRowVersion", "Invalid workOrderVersion format.");
+            }
+        }
+    }
+}
diff --git a/SeaHaven.Services/Implementation/WorkOrderDetailService.cs b/SeaHaven.Services/Implementation/WorkOrderDetailService.cs
new file mode 100644
index 0000000..849c5f6
--- /dev/null
+++ b/SeaHaven.Services/Implementation/WorkOrderDetailService.cs
@@ -0,0 +1,182 @@
+using SeaHaven.DataServices.Interfaces;
+using SeaHaven.Services.DTOs;
+using SeaHaven.Services.Helpers;
+using SeaHaven.Services.Interfaces;
+
+namespace SeaHaven.Services.Implementation
+{
+    public class WorkOrderDetailService : IWorkOrderDetailService
+    {
+        private readonly IWorkOrderBoardService _boardService;
+        private readonly IWorkOrderDetailDataService _detailData;
+        private readonly ICompletionDocTemplateDataService _templateData;
+        private readonly IUserDataService _userDataService;
+
+        public WorkOrderDetailService(
+            IWorkOrderBoardService boardService,
+            IWorkOrderDetailDataService detailData,
+            ICompletionDocTemplateDataService templateData,
+            IUserDataService userDataService)
+        {
+            _boardService = boardService;
+            _detailData = detailData;
+            _templateData = templateData;
+            _userDataService = userDataService;
+        }
+
+        public async Task<WorkOrderDetailDto?> GetDetailAsync(int workOrderId)
+        {
+            if (!await _detailData.ExistsAsync(workOrderId))
+                return null;
+
+            var boardRow = await _boardService.GetBoardRowAsync(workOrderId);
+            if (boardRow == null)
+                return null;
+
+            var extended = await _detailData.GetExtendedFieldsAsync(workOrderId);
+            var comments = await _detailData.GetCommentsAsync(workOrderId);
+            var audit = await _detailData.GetAuditLogsAsync(workOrderId, 50);
+            var attachments = await _detailData.GetAttachmentsAsync(workOrderId);
+            var signoffs = await _detailData.GetDispatchSignoffsAsync(workOrderId);
+            var workOrder = await _detailData.GetWorkOrderForMediaAsync(workOrderId);
+
+            var template = await _templateData.ResolveForWorkOrderAsync(
+                extended?.Trade ?? boardRow.Pm,
+                boardRow.WorkOrderType);
+
+            var authorIds = WorkOrderCommentProjection.CollectAuthorUserIds(comments);
+            var authorNames = await _userDataService.GetDisplayNamesByIdsAsync(authorIds);
+
+            return new WorkOrderDetailDto
+            {
+                Info = MapInfo(boardRow, extended),
+                Completion = MapCompletion(extended, boardRow.DocStatus, template, signoffs),
+                Comments = WorkOrderCommentProjection.ToDtos(comments, authorNames),
+                Audit = await MapAuditAsync(audit),
+                Media = workOrder == null
+                    ? new List<WorkOrderMediaFileDto>()
+                    : WorkOrderMediaProjection.ProjectAll(workOrder, attachments)
+            };
+        }
+
+        public async Task<IReadOnlyList<WorkOrderAuditEntryDto>?> GetAuditAsync(int workOrderId, int limit = 50)
+        {
+            if (!await _detailData.ExistsAsync(workOrderId))
+                return null;
+
+            var logs = await _detailData.GetAuditLogsAsync(workOrderId, limit);
+            return await MapAuditAsync(logs);
+        }
+
+        private async Task<List<WorkOrderAuditEntryDto>> MapAuditAsync(IReadOnlyList<Data.SeaHavenIndustries.WorkOrderAuditLog> logs)
+        {
+            var userIds = WorkOrderAuditProjection.CollectAssignToUserIds(logs);
+            var displayNames = await _userDataService.GetDisplayNamesByIdsAsync(userIds);
+            return WorkOrderAuditProjection.ToDtos(logs, displayNames);
+        }
+
+        private static WorkOrderDetailInfoDto MapInfo(
+            WorkOrderBoardRowDto row,
+            WorkOrderDetailExtendedFields? extended)
+        {
+            return new WorkOrderDetailInfoDto
+            {
+                Id = row.Id,
+                WoNumber = row.WoNumber,
+                RescheduleCount = row.RescheduleCount,
+                CarriedOver = row.CarriedOver,
+                WorkOrderType = row.WorkOrderType,
+                IsPastDue = row.IsPastDue,
+                SiteCode = row.SiteCode,
+                LocationName = row.LocationName,
+                PocName = row.PocName,
+                PocPhone = row.PocPhone,
+                PocNotes = row.PocNotes,
+                LifecycleStatus = row.LifecycleStatus,
+                LifecycleStatusLabel = row.LifecycleStatusLabel,
+                LegacyStatus = row.LegacyStatus,
+                DispatcherId = row.DispatcherId,
+                DispatcherName = row.DispatcherName,
+                Initials = row.Initials,
+                Color = row.Color,
+                DueDate = row.DueDate,
+                ScheduledDate = row.ScheduledDate,
+                TargetWeek = row.TargetWeek,
+                ScheduleWeekOnly = row.ScheduleWeekOnly,
+                DayGroup = row.DayGroup,
+                VendorId = row.VendorId,
+                VendorName = row.VendorName,
+                TechName = row.TechName,
+                TechPhone = row.TechPhone,
+                ApptDate = row.ApptDate,
+                ApptTime = row.ApptTime,
+                Pm = row.Pm,
+                ServiceNotes = extended?.ServiceNotes ?? row.ServiceNotes,
+                ExtraServices = ParseExtraServices(extended?.ExtraServices) ?? row.ExtraServices,
+                DocStatus = row.DocStatus,
+                FlagColor = row.FlagColor,
+                PrimaryDispatchId = row.PrimaryDispatchId,
+                RowVersion = row.RowVersion,
+                DispatchRowVersion = row.DispatchRowVersion,
+                Description = extended?.Description,
+                Trade = extended?.Trade,
+                Problem = extended?.Problem,
+                SubTrade = extended?.SubTrade,
+                OriginalWeek = extended?.OriginalWeek,
+                OriginalDate = extended?.OriginalDate,
+                CompletedDate = extended?.CompletedDate,
+                VendorNotes = extended?.VendorNotes
+            };
+        }
+
+        private static List<string>? ParseExtraServices(string? json)
+        {
+            if (string.IsNullOrWhiteSpace(json))
+                return null;
+
+            try
+            {
+                var list = System.Text.Json.JsonSerializer.Deserialize<List<string>>(json);
+                return list is { Count: > 0 } ? list : null;
+            }
+            catch (System.Text.Json.JsonException)
+            {
+                return null;
+            }
+        }
+
+        private static WorkOrderCompletionDto MapCompletion(
+            WorkOrderDetailExtendedFields? extended,
+            Data.SeaHavenIndustries.Enums.DocStatus? docStatus,
+            CompletionDocTemplateRow? template,
+            IReadOnlyList<DispatchSignoffRow> signoffs)
+        {
+            return new WorkOrderCompletionDto
+            {
+                DocStatus = docStatus,
+                Template = template == null ? null : MapTemplate(template),
+                SignOffName = extended?.SignOffName,
+                SignOffAttachment = extended?.SignOffAttachment,
+                SignOffSignature = extended?.SignOffSignature,
+                DispatchSignoffs = signoffs.Select(s => new DispatchSignoffDto
+                {
+                    DispatchId = s.DispatchId,
+                    SignoffType = s.SignoffType,
+                    Name = s.Name,
+                    SignedAt = s.SignedAt?.ToUniversalTime().ToString("o")
+                }).ToList()
+            };
+        }
+
+        internal static CompletionDocTemplateDto MapTemplate(CompletionDocTemplateRow template)
+            => new()
+            {
+                Id = template.Id,
+                Name = template.Name,
+                ServiceKey = template.ServiceKey,
+                WorkOrderType = template.WorkOrderType,
+                TemplateUrl = template.TemplateUrl,
+                IsActive = template.IsActive
+            };
+    }
+}
diff --git a/SeaHaven.Services/Implementation/WorkOrderFieldLockService.cs b/SeaHaven.Services/Implementation/WorkOrderFieldLockService.cs
new file mode 100644
index 0000000..442fbb3
--- /dev/null
+++ b/SeaHaven.Services/Implementation/WorkOrderFieldLockService.cs
@@ -0,0 +1,47 @@
+using Data.SeaHavenIndustries;
+using Microsoft.EntityFrameworkCore;
+using SeaHaven.Services.Interfaces;
+
+namespace SeaHaven.Services.Implementation
+{
+    public class WorkOrderFieldLockService : IWorkOrderFieldLockService
+    {
+        private readonly ApplicationDbContext _context;
+
+        public WorkOrderFieldLockService(ApplicationDbContext context)
+        {
+            _context = context;
+        }
+
+        public async Task<bool> IsLockedAsync(int workOrderId, string fieldName)
+        {
+            if (IsTracked(workOrderId, fieldName))
+                return true;
+
+            return await _context.WorkOrderFieldLocks
+                .AnyAsync(l => l.WorkOrderId == workOrderId && l.FieldName == fieldName);
+        }
+
+        public async Task LockFieldAsync(int workOrderId, string fieldName, string? userId)
+        {
+            if (IsTracked(workOrderId, fieldName))
+                return;
+
+            if (await IsLockedAsync(workOrderId, fieldName))
+                return;
+
+            _context.WorkOrderFieldLocks.Add(new WorkOrderFieldLock
+            {
+                WorkOrderId = workOrderId,
+                FieldName = fieldName,
+                LockedAt = DateTime.UtcNow,
+                LockedByUserId = userId
+            });
+        }
+
+        private bool IsTracked(int workOrderId, string fieldName)
+            => _context.WorkOrderFieldLocks.Local.Any(l =>
+                l.WorkOrderId == workOrderId &&
+                string.Equals(l.FieldName, fieldName, StringComparison.OrdinalIgnoreCase));
+    }
+}
diff --git a/SeaHaven.Services/Implementation/WorkOrderIngestService.cs b/SeaHaven.Services/Implementation/WorkOrderIngestService.cs
new file mode 100644
index 0000000..aa0638e
--- /dev/null
+++ b/SeaHaven.Services/Implementation/WorkOrderIngestService.cs
@@ -0,0 +1,216 @@
+using Data.SeaHavenIndustries;
+using Microsoft.EntityFrameworkCore;
+using SeaHaven.Services.DTOs;
+using SeaHaven.Services.Helpers;
+using SeaHaven.Services.Interfaces;
+
+namespace SeaHaven.Services.Implementation
+{
+    public class WorkOrderIngestService : IWorkOrderIngestService
+    {
+        private readonly ApplicationDbContext _db;
+        private readonly ISyncFieldMergePolicy _mergePolicy;
+        private readonly IWorkOrderFieldLockService _fieldLocks;
+        private readonly IWorkOrderAuditService _audit;
+
+        public WorkOrderIngestService(
+            ApplicationDbContext db,
+            ISyncFieldMergePolicy mergePolicy,
+            IWorkOrderFieldLockService fieldLocks,
+            IWorkOrderAuditService audit)
+        {
+            _db = db;
+            _mergePolicy = mergePolicy;
+            _fieldLocks = fieldLocks;
+            _audit = audit;
+        }
+
+        public async Task<WorkOrderIngestBatchResultDto> UpsertBatchAsync(
+            IReadOnlyList<WorkOrderIngestPayloadDto> items,
+            CancellationToken cancellationToken = default)
+        {
+            var result = new WorkOrderIngestBatchResultDto();
+            if (items.Count == 0)
+                return result;
+
+            var useTransaction = _db.Database.IsRelational();
+            await using var transaction = useTransaction
+                ? await _db.Database.BeginTransactionAsync(cancellationToken)
+                : null;
+
+            try
+            {
+                var nextSeed = await AllocateNextWoSeedAsync(cancellationToken);
+
+                foreach (var item in items)
+                {
+                    if (string.IsNullOrWhiteSpace(item.ExternalWorkOrderId))
+                    {
+                        result.Skipped++;
+                        continue;
+                    }
+
+                    var (upsert, updatedSeed) = await UpsertOneAsync(item, nextSeed, cancellationToken);
+                    nextSeed = updatedSeed;
+                    result.Results.Add(upsert);
+                    if (upsert.Created)
+                        result.Created++;
+                    else
+                        result.Updated++;
+                }
+
+                await _db.SaveChangesAsync(cancellationToken);
+                if (transaction != null)
+                    await transaction.CommitAsync(cancellationToken);
+            }
+            catch
+            {
+                if (transaction != null)
+                    await transaction.RollbackAsync(cancellationToken);
+                throw;
+            }
+
+            return result;
+        }
+
+        private async Task<(WorkOrderIngestItemResultDto Result, int NextSeed)> UpsertOneAsync(
+            WorkOrderIngestPayloadDto item,
+            int nextSeed,
+            CancellationToken cancellationToken)
+        {
+            var existing = await _db.workOrders
+                .FirstOrDefaultAsync(w => w.ExternalWorkOrderId == item.ExternalWorkOrderId, cancellationToken);
+
+            var locationId = await ResolveLocationIdAsync(
+                item.SiteCode, item.Building, item.Address, cancellationToken);
+
+            if (existing == null)
+            {
+                var (woNumber, updatedSeed) = AllocateInternalWoNumber(nextSeed);
+                var wo = new WorkOrder
+                {
+                    InternalWONumber = woNumber,
+                    ExternalWorkOrderId = item.ExternalWorkOrderId,
+                    WorkerOrderNumber = item.ExternalWorkOrderId,
+                    WorkerOrderTitle = item.Description,
+                    Description = item.Description,
+                    Status = WorkOrderIngestFieldMapper.MapStatus(item.WoStatus) ?? "Open",
+                    Priority = WorkOrderIngestFieldMapper.MapSeverityToPriority(item.Severity),
+                    Severity = item.Severity,
+                    Customer = item.Customer,
+                    SiteCode = item.SiteCode,
+                    Building = item.Building,
+                    LocationId = locationId,
+                    DueDate = item.DueDate,
+                    DateReported = item.DateReported,
+                    ScheduledStart = item.ScheduledStart,
+                    SourceEmailS3Key = item.SourceEmailS3Key,
+                    CreatedDate = item.CreatedAt ?? DateTime.UtcNow,
+                    istemplate = false
+                };
+                _db.workOrders.Add(wo);
+                await _db.SaveChangesAsync(cancellationToken);
+
+                return (new WorkOrderIngestItemResultDto
+                {
+                    ExternalWorkOrderId = item.ExternalWorkOrderId,
+                    WorkOrderId = wo.Id,
+                    Created = true
+                }, updatedSeed);
+            }
+
+            var syncContext = new WorkOrderSyncContext
+            {
+                WorkOrder = existing,
+                FieldLocks = _fieldLocks,
+                Audit = _audit
+            };
+
+            if (item.Description != null)
+            {
+                await _mergePolicy.TryApplyAsync(syncContext, "Description", item.Description);
+                await _mergePolicy.TryApplyAsync(syncContext, "WorkerOrderTitle", item.Description);
+            }
+
+            var mappedStatus = WorkOrderIngestFieldMapper.MapStatus(item.WoStatus);
+            if (mappedStatus != null)
+                await _mergePolicy.TryApplyAsync(syncContext, "Status", mappedStatus);
+
+            var priority = WorkOrderIngestFieldMapper.MapSeverityToPriority(item.Severity);
+            if (priority != null)
+                await _mergePolicy.TryApplyAsync(syncContext, "Priority", priority);
+
+            if (item.Severity != null)
+                await _mergePolicy.TryApplyAsync(syncContext, "Severity", item.Severity);
+
+            if (item.SiteCode != null)
+                await _mergePolicy.TryApplyAsync(syncContext, "SiteCode", item.SiteCode);
+
+            if (item.Building != null)
+                await _mergePolicy.TryApplyAsync(syncContext, "Building", item.Building);
+
+            if (locationId.HasValue)
+                await _mergePolicy.TryApplyAsync(syncContext, "LocationId", locationId.Value);
+
+            if (item.DueDate.HasValue)
+                await _mergePolicy.TryApplyAsync(syncContext, "DueDate", item.DueDate.Value);
+
+            if (item.Customer != null)
+                existing.Customer = item.Customer;
+
+            // Sync-owned metadata (not in ShocOwnedFieldSet)
+            existing.DateReported = item.DateReported ?? existing.DateReported;
+            existing.ScheduledStart = item.ScheduledStart ?? existing.ScheduledStart;
+            existing.SourceEmailS3Key = item.SourceEmailS3Key ?? existing.SourceEmailS3Key;
+
+            return (new WorkOrderIngestItemResultDto
+            {
+                ExternalWorkOrderId = item.ExternalWorkOrderId,
+                WorkOrderId = existing.Id,
+                Created = false
+            }, nextSeed);
+        }
+
+        private async Task<int> AllocateNextWoSeedAsync(CancellationToken cancellationToken)
+        {
+            var maxId = await _db.workOrders.MaxAsync(w => (int?)w.Id, cancellationToken) ?? 0;
+            return Math.Max(maxId + 1, 1);
+        }
+
+        private static (string Number, int NextSeed) AllocateInternalWoNumber(int seed)
+        {
+            if (!WorkOrderNumberNormalizer.TryNormalize(seed.ToString(), out var normalized, out _))
+                normalized = seed.ToString().PadLeft(11, '0');
+            return (normalized, seed + 1);
+        }
+
+        private async Task<int?> ResolveLocationIdAsync(
+            string? siteCode,
+            string? building,
+            string? address,
+            CancellationToken cancellationToken)
+        {
+            if (string.IsNullOrWhiteSpace(siteCode) && string.IsNullOrWhiteSpace(building))
+                return null;
+
+            var matchCode = siteCode ?? building;
+            var existing = await _db.Locations
+                .FirstOrDefaultAsync(l => l.Name == matchCode || l.Title == matchCode, cancellationToken);
+
+            if (existing != null)
+                return existing.Id;
+
+            var location = new Locations
+            {
+                Name = matchCode,
+                Title = building,
+                Address1 = address,
+                Status = "Active"
+            };
+
+            _db.Locations.Add(location);
+            await _db.SaveChangesAsync(cancellationToken);
+            return location.Id;
+        }
+    }
+}
diff --git a/SeaHaven.Services/Implementation/WorkOrderMediaService.cs b/SeaHaven.Services/Implementation/WorkOrderMediaService.cs
new file mode 100644
index 0000000..8de3380
--- /dev/null
+++ b/SeaHaven.Services/Implementation/WorkOrderMediaService.cs
@@ -0,0 +1,134 @@
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+using Microsoft.EntityFrameworkCore;
+using SeaHaven.DataServices.Interfaces;
+using SeaHaven.Services.DTOs;
+using SeaHaven.Services.Exceptions;
+using SeaHaven.Services.Helpers;
+using SeaHaven.Services.Interfaces;
+
+namespace SeaHaven.Services.Implementation
+{
+    public class WorkOrderMediaService : IWorkOrderMediaService
+    {
+        private readonly ApplicationDbContext _context;
+        private readonly IWorkOrderDetailDataService _detailData;
+
+        public WorkOrderMediaService(ApplicationDbContext context, IWorkOrderDetailDataService detailData)
+        {
+            _context = context;
+            _detailData = detailData;
+        }
+
+        public async Task<IReadOnlyList<WorkOrderMediaFileDto>?> GetMediaAsync(int workOrderId)
+        {
+            if (!await _detailData.ExistsAsync(workOrderId))
+                return null;
+
+            var workOrder = await _detailData.GetWorkOrderForMediaAsync(workOrderId);
+            if (workOrder == null)
+                return null;
+
+            var attachments = await _detailData.GetAttachmentsAsync(workOrderId);
+            return WorkOrderMediaProjection.ProjectAll(workOrder, attachments);
+        }
+
+        public async Task<WorkOrderMediaFileDto> AddMediaAsync(
+            int workOrderId,
+            WorkOrderMediaCategory category,
+            string fileUrl,
+            string? actorId)
+        {
+            if (!await _detailData.ExistsAsync(workOrderId))
+                throw new WorkOrderBoardValidationException("NotFound", "Work order not found.");
+
+            var workOrder = await _context.workOrders.FirstOrDefaultAsync(w => w.Id == workOrderId);
+            if (workOrder == null)
+                throw new WorkOrderBoardValidationException("NotFound", "Work order not found.");
+
+            if (WorkOrderBoardMutationRules.IsReadOnly(workOrder.LifecycleStatus))
+                throw new WorkOrderBoardValidationException("ReadOnly", "Work order is read-only in its current status.");
+
+            if (category == WorkOrderMediaCategory.Completion)
+            {
+                throw new WorkOrderBoardValidationException(
+                    "UseCompletionDocEndpoint",
+                    "Completion documents must be uploaded via POST /api/workorders/{id}/completion-doc.");
+            }
+
+            if (category == WorkOrderMediaCategory.Before)
+            {
+                workOrder.BeforPhotoAttachment = fileUrl;
+                await _context.SaveChangesAsync();
+                return new WorkOrderMediaFileDto
+                {
+                    Id = -1,
+                    Category = category,
+                    Url = fileUrl,
+                    IsLegacy = true
+                };
+            }
+
+            if (category == WorkOrderMediaCategory.After)
+            {
+                workOrder.AfterPhotoAttachment = fileUrl;
+                await _context.SaveChangesAsync();
+                return new WorkOrderMediaFileDto
+                {
+                    Id = -2,
+                    Category = category,
+                    Url = fileUrl,
+                    IsLegacy = true
+                };
+            }
+
+            var attachment = new WorkOrderAttachments
+            {
+                WorkorderId = workOrderId,
+                Attachments = fileUrl,
+                Category = category,
+                CreatedDate = DateTime.UtcNow,
+                createdby = actorId
+            };
+
+            _context.workOrderAttachments.Add(attachment);
+            await _context.SaveChangesAsync();
+
+            return new WorkOrderMediaFileDto
+            {
+                Id = attachment.Id,
+                Category = category,
+                Url = fileUrl,
+                UploadedAt = attachment.CreatedDate?.ToUniversalTime().ToString("o"),
+                IsLegacy = false
+            };
+        }
+
+        public async Task DeleteMediaAsync(int workOrderId, int mediaId, string? actorId)
+        {
+            if (mediaId <= 0)
+                throw new WorkOrderBoardValidationException("InvalidMedia", "Legacy media cannot be deleted via this endpoint.");
+
+            if (!await _detailData.ExistsAsync(workOrderId))
+                throw new WorkOrderBoardValidationException("NotFound", "Work order not found.");
+
+            var workOrder = await _context.workOrders.FirstOrDefaultAsync(w => w.Id == workOrderId);
+            if (workOrder == null)
+                throw new WorkOrderBoardValidationException("NotFound", "Work order not found.");
+
+            if (WorkOrderBoardMutationRules.IsReadOnly(workOrder.LifecycleStatus))
+                throw new WorkOrderBoardValidationException("ReadOnly", "Work order is read-only in its current status.");
+
+            var attachment = await _context.workOrderAttachments
+                .FirstOrDefaultAsync(a => a.Id == mediaId && a.WorkorderId == workOrderId && a.IsDeleted != true);
+
+            if (attachment == null)
+                throw new WorkOrderBoardValidationException("NotFound", "Media not found.");
+
+            attachment.IsDeleted = true;
+            attachment.DeletionTime = DateTime.UtcNow;
+            attachment.DeleterUserId = actorId;
+            await _context.SaveChangesAsync();
+        }
+    }
+}
diff --git a/SeaHaven.Services/Implementation/WorkOrderOpsHealthService.cs b/SeaHaven.Services/Implementation/WorkOrderOpsHealthService.cs
new file mode 100644
index 0000000..11656ed
--- /dev/null
+++ b/SeaHaven.Services/Implementation/WorkOrderOpsHealthService.cs
@@ -0,0 +1,81 @@
+using Data.SeaHavenIndustries;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Options;
+using SeaHaven.Services.DTOs;
+using SeaHaven.Services.Interfaces;
+
+namespace SeaHaven.Services.Implementation
+{
+    public class WorkOrderOpsHealthService : IWorkOrderOpsHealthService
+    {
+        private readonly ApplicationDbContext _db;
+        private readonly WorkOrderJobRunStateAccessor _runState;
+        private readonly WorkOrderOpsHealthOptions _options;
+
+        public WorkOrderOpsHealthService(
+            ApplicationDbContext db,
+            WorkOrderJobRunStateAccessor runState,
+            IOptions<WorkOrderOpsHealthOptions> options)
+        {
+            _db = db;
+            _runState = runState;
+            _options = options.Value;
+        }
+
+        public async Task<WorkOrderOpsHealthDto> GetHealthAsync(CancellationToken cancellationToken = default)
+        {
+            var since = DateTime.UtcNow.AddHours(-24);
+
+            var syncRejected = await _db.WorkOrderAuditLogs
+                .CountAsync(l => l.Action == "SyncRejected" && l.CreatedAt >= since, cancellationToken);
+
+            var fieldLocks = await _db.WorkOrderFieldLocks.CountAsync(cancellationToken);
+
+            var state = _runState.State;
+            DateTime? ledgerWeekRolled = null;
+            if (await _db.WorkOrderWeekRolledLedgers.AnyAsync(cancellationToken))
+            {
+                ledgerWeekRolled = await _db.WorkOrderWeekRolledLedgers
+                    .MaxAsync(l => (DateTime?)l.ProcessedAt, cancellationToken);
+            }
+
+            return new WorkOrderOpsHealthDto
+            {
+                LastWeekRolledRunUtc = state.LastWeekRolledRunUtc ?? ledgerWeekRolled,
+                LastPastDueCacheRunUtc = state.LastPastDueCacheRunUtc,
+                LastWeekRolledError = state.LastWeekRolledError,
+                LastPastDueCacheError = state.LastPastDueCacheError,
+                SyncRejectedLast24h = syncRejected,
+                FieldLockCount = fieldLocks,
+                SyncEnabled = _options.SyncEnabled,
+                IngestEnabled = _options.IngestEnabled,
+                LegacyDeprecationEnabled = _options.LegacyDeprecationEnabled,
+                LegacySunsetDate = _options.LegacySunsetDate,
+                CheckedAtUtc = DateTime.UtcNow
+            };
+        }
+    }
+
+    /// <summary>Options bridged from API configuration for health snapshots.</summary>
+    public class WorkOrderOpsHealthOptions
+    {
+        public bool SyncEnabled { get; set; } = true;
+        public bool IngestEnabled { get; set; } = true;
+        public bool LegacyDeprecationEnabled { get; set; }
+        public string? LegacySunsetDate { get; set; }
+    }
+
+    /// <summary>Shared in-memory job run timestamps (API hosted services + ops health).</summary>
+    public class WorkOrderJobRunStateAccessor
+    {
+        public WorkOrderJobRunState State { get; } = new();
+    }
+
+    public class WorkOrderJobRunState
+    {
+        public DateTime? LastWeekRolledRunUtc { get; set; }
+        public DateTime? LastPastDueCacheRunUtc { get; set; }
+        public string? LastWeekRolledError { get; set; }
+        public string? LastPastDueCacheError { get; set; }
+    }
+}
diff --git a/SeaHaven.Services/Implementation/WorkOrderWeekRolledService.cs b/SeaHaven.Services/Implementation/WorkOrderWeekRolledService.cs
new file mode 100644
index 0000000..ec4eebf
--- /dev/null
+++ b/SeaHaven.Services/Implementation/WorkOrderWeekRolledService.cs
@@ -0,0 +1,110 @@
+using System.Diagnostics;
+using Microsoft.Extensions.Logging;
+using SeaHaven.DataServices.Interfaces;
+using SeaHaven.Services.DTOs;
+using SeaHaven.Services.Helpers;
+using SeaHaven.Services.Interfaces;
+
+namespace SeaHaven.Services.Implementation
+{
+    public class WorkOrderWeekRolledService : IWorkOrderWeekRolledService
+    {
+        private const int BatchSize = 500;
+
+        private readonly IWorkOrderDomainJobDataService _dataService;
+        private readonly IWorkOrderAuditService _auditService;
+        private readonly ILogger<WorkOrderWeekRolledService> _logger;
+
+        public WorkOrderWeekRolledService(
+            IWorkOrderDomainJobDataService dataService,
+            IWorkOrderAuditService auditService,
+            ILogger<WorkOrderWeekRolledService> logger)
+        {
+            _dataService = dataService;
+            _auditService = auditService;
+            _logger = logger;
+        }
+
+        public async Task<WeekRolledJobResult> ProcessWeekRolledAsync(
+            DateOnly sourceWeekStart,
+            CancellationToken cancellationToken = default)
+        {
+            var stopwatch = Stopwatch.StartNew();
+            var sourceWeekEnd = WorkOrderOperationalWeek.GetOperationalWeekEnd(sourceWeekStart);
+            var correlationId = WorkOrderOperationalWeek.BuildWeekCorrelationId(sourceWeekStart);
+
+            var processed = 0;
+            var skipped = 0;
+            var failed = 0;
+
+            _logger.LogInformation(
+                "WeekRolled job started. CorrelationId={CorrelationId}, SourceWeekStart={SourceWeekStart}, SourceWeekEnd={SourceWeekEnd}",
+                correlationId, sourceWeekStart, sourceWeekEnd);
+
+            // Always fetch the first page of remaining candidates. Processed rows write ledger
+            // entries that exclude them from the next query; offset paging would skip unprocessed rows.
+            while (!cancellationToken.IsCancellationRequested)
+            {
+                var candidates = await _dataService.GetWeekRolledCandidatesAsync(
+                    sourceWeekStart, sourceWeekEnd, BatchSize, cancellationToken);
+
+                if (candidates.Count == 0)
+                    break;
+
+                foreach (var workOrderId in candidates)
+                {
+                    if (cancellationToken.IsCancellationRequested)
+                        break;
+
+                    try
+                    {
+                        var outcome = await _dataService.TryProcessWeekRolledAsync(
+                            workOrderId, sourceWeekStart, correlationId, cancellationToken);
+
+                        if (outcome.Skipped)
+                        {
+                            skipped++;
+                            continue;
+                        }
+
+                        if (outcome.Processed)
+                        {
+                            await _auditService.LogWeekRolledAsync(
+                                workOrderId, outcome.OldCarriedOver, outcome.NewCarriedOver, correlationId);
+                            processed++;
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        failed++;
+                        _logger.LogError(ex,
+                            "WeekRolled failed for WorkOrderId={WorkOrderId}, CorrelationId={CorrelationId}",
+                            workOrderId, correlationId);
+                    }
+                }
+
+                if (candidates.Count < BatchSize)
+                    break;
+            }
+
+            stopwatch.Stop();
+
+            var result = new WeekRolledJobResult
+            {
+                Processed = processed,
+                Skipped = skipped,
+                Failed = failed,
+                CorrelationId = correlationId,
+                SourceWeekStart = sourceWeekStart,
+                SourceWeekEnd = sourceWeekEnd,
+                DurationMs = stopwatch.ElapsedMilliseconds
+            };
+
+            _logger.LogInformation(
+                "WeekRolled job completed. CorrelationId={CorrelationId}, Processed={Processed}, Skipped={Skipped}, Failed={Failed}, DurationMs={DurationMs}",
+                correlationId, processed, skipped, failed, result.DurationMs);
+
+            return result;
+        }
+    }
+}
diff --git a/SeaHaven.Services/Interfaces/ILocationService.cs b/SeaHaven.Services/Interfaces/ILocationService.cs
index 7bf9d4e..dd70421 100644
--- a/SeaHaven.Services/Interfaces/ILocationService.cs
+++ b/SeaHaven.Services/Interfaces/ILocationService.cs
@@ -9,6 +9,7 @@ namespace SeaHaven.Services.Interfaces
         Task<IEnumerable<LocationDTO>> GetAllLocationsAsync();
         Task<IEnumerable<LocationDTO>> GetLocationsByAccountIdAsync(int accountId);
         Task<PagedResult<LocationDTO>> GetLocationsPagedAsync(int page, int pageSize, string? search = null);
+        Task<IReadOnlyList<SiteOptionDTO>> GetSiteOptionsAsync(string? search = null);
         Task<LocationDTO> CreateLocationAsync(CreateLocationDTO dto, string userId);
         Task<LocationDTO> UpdateLocationAsync(int id, UpdateLocationDTO dto, string userId);
         Task DeleteLocationAsync(int id, string userId);
diff --git a/SeaHaven.Services/Interfaces/IPastDueCacheService.cs b/SeaHaven.Services/Interfaces/IPastDueCacheService.cs
new file mode 100644
index 0000000..e87f498
--- /dev/null
+++ b/SeaHaven.Services/Interfaces/IPastDueCacheService.cs
@@ -0,0 +1,9 @@
+using SeaHaven.Services.DTOs;
+
+namespace SeaHaven.Services.Interfaces
+{
+    public interface IPastDueCacheService
+    {
+        Task<PastDueCacheJobResult> RefreshAsync(CancellationToken cancellationToken = default);
+    }
+}
diff --git a/SeaHaven.Services/Interfaces/ISyncFieldMergePolicy.cs b/SeaHaven.Services/Interfaces/ISyncFieldMergePolicy.cs
new file mode 100644
index 0000000..12f9398
--- /dev/null
+++ b/SeaHaven.Services/Interfaces/ISyncFieldMergePolicy.cs
@@ -0,0 +1,18 @@
+namespace SeaHaven.Services.Interfaces
+{
+    public interface ISyncFieldMergePolicy
+    {
+        IReadOnlySet<string> ShocOwnedFields { get; }
+
+        Task<bool> CanSyncOverwriteAsync(int workOrderId, string fieldName);
+
+        Task<bool> TryApplyAsync(WorkOrderSyncContext context, string fieldName, object? incomingValue);
+    }
+
+    public class WorkOrderSyncContext
+    {
+        public required Data.SeaHavenIndustries.WorkOrder WorkOrder { get; init; }
+        public required SeaHaven.Services.Interfaces.IWorkOrderFieldLockService FieldLocks { get; init; }
+        public required SeaHaven.Services.Interfaces.IWorkOrderAuditService Audit { get; init; }
+    }
+}
diff --git a/SeaHaven.Services/Interfaces/IWorkOrderAdvancedSearchService.cs b/SeaHaven.Services/Interfaces/IWorkOrderAdvancedSearchService.cs
new file mode 100644
index 0000000..8da8835
--- /dev/null
+++ b/SeaHaven.Services/Interfaces/IWorkOrderAdvancedSearchService.cs
@@ -0,0 +1,11 @@
+using SeaHaven.Services.DTOs;
+
+namespace SeaHaven.Services.Interfaces
+{
+    public interface IWorkOrderAdvancedSearchService
+    {
+        Task<PagedResult<WorkOrderBoardRowDto>> SearchAsync(
+            WorkOrderAdvancedSearchQueryDto query,
+            string? currentUserId);
+    }
+}
diff --git a/SeaHaven.Services/Interfaces/IWorkOrderAuditService.cs b/SeaHaven.Services/Interfaces/IWorkOrderAuditService.cs
new file mode 100644
index 0000000..eda29f8
--- /dev/null
+++ b/SeaHaven.Services/Interfaces/IWorkOrderAuditService.cs
@@ -0,0 +1,29 @@
+using Data.SeaHavenIndustries.Enums;
+
+namespace SeaHaven.Services.Interfaces
+{
+    public interface IWorkOrderAuditService
+    {
+        Task LogAsync(
+            int workOrderId,
+            AuditActionType action,
+            AuditEventType eventType,
+            AuditActorType actorType,
+            string fieldName,
+            string? oldValue,
+            string? newValue,
+            string? actorId = null,
+            int? dispatchId = null,
+            string? correlationId = null);
+
+        Task LogStatusChangedAsync(int workOrderId, string? oldStatus, string? newStatus, string? actorId);
+        Task LogAssignmentChangedAsync(int workOrderId, string? oldValue, string? newValue, string? actorId);
+        Task LogSyncRejectedAsync(int workOrderId, string fieldName, string? oldValue, string? newValue);
+        Task LogWeekRolledAsync(int workOrderId, int oldCarriedOver, int newCarriedOver, string correlationId);
+
+        void StageFieldChanged(int workOrderId, string fieldName, string? oldValue, string? newValue, string? actorId, int? dispatchId = null);
+        void StageStatusChanged(int workOrderId, string? oldStatus, string? newStatus, string? actorId);
+        void StageAssignmentChanged(int workOrderId, string? oldValue, string? newValue, string? actorId);
+        void StageCreated(int workOrderId, string? actorId, string? woNumber);
+    }
+}
diff --git a/SeaHaven.Services/Interfaces/IWorkOrderBoardCancelService.cs b/SeaHaven.Services/Interfaces/IWorkOrderBoardCancelService.cs
new file mode 100644
index 0000000..d0b647b
--- /dev/null
+++ b/SeaHaven.Services/Interfaces/IWorkOrderBoardCancelService.cs
@@ -0,0 +1,9 @@
+using SeaHaven.Services.DTOs;
+
+namespace SeaHaven.Services.Interfaces
+{
+    public interface IWorkOrderBoardCancelService
+    {
+        Task<WorkOrderBoardRowDto> CancelAsync(int workOrderId, string? actorId);
+    }
+}
diff --git a/SeaHaven.Services/Interfaces/IWorkOrderBoardCreateService.cs b/SeaHaven.Services/Interfaces/IWorkOrderBoardCreateService.cs
new file mode 100644
index 0000000..9818053
--- /dev/null
+++ b/SeaHaven.Services/Interfaces/IWorkOrderBoardCreateService.cs
@@ -0,0 +1,9 @@
+using SeaHaven.Services.DTOs;
+
+namespace SeaHaven.Services.Interfaces
+{
+    public interface IWorkOrderBoardCreateService
+    {
+        Task<WorkOrderBoardRowDto> CreateAsync(WorkOrderBoardCreateRequestDto request, string? actorId);
+    }
+}
diff --git a/SeaHaven.Services/Interfaces/IWorkOrderBoardService.cs b/SeaHaven.Services/Interfaces/IWorkOrderBoardService.cs
new file mode 100644
index 0000000..2a964cf
--- /dev/null
+++ b/SeaHaven.Services/Interfaces/IWorkOrderBoardService.cs
@@ -0,0 +1,11 @@
+using SeaHaven.Services.DTOs;
+
+namespace SeaHaven.Services.Interfaces
+{
+    public interface IWorkOrderBoardService
+    {
+        Task<WorkOrderBoardResponseDto> GetBoardAsync(WorkOrderBoardQueryDto query, string? currentUserId);
+        Task<IReadOnlyList<DispatcherLookupDto>> GetDispatcherLookupsAsync();
+        Task<WorkOrderBoardRowDto?> GetBoardRowAsync(int workOrderId);
+    }
+}
diff --git a/SeaHaven.Services/Interfaces/IWorkOrderBoardUpdateService.cs b/SeaHaven.Services/Interfaces/IWorkOrderBoardUpdateService.cs
new file mode 100644
index 0000000..7631d35
--- /dev/null
+++ b/SeaHaven.Services/Interfaces/IWorkOrderBoardUpdateService.cs
@@ -0,0 +1,9 @@
+using SeaHaven.Services.DTOs;
+
+namespace SeaHaven.Services.Interfaces
+{
+    public interface IWorkOrderBoardUpdateService
+    {
+        Task<WorkOrderBoardRowDto> PatchFieldAsync(int workOrderId, WorkOrderBoardPatchRequestDto request, string? actorId);
+    }
+}
diff --git a/SeaHaven.Services/Interfaces/IWorkOrderCommentService.cs b/SeaHaven.Services/Interfaces/IWorkOrderCommentService.cs
new file mode 100644
index 0000000..92c64bc
--- /dev/null
+++ b/SeaHaven.Services/Interfaces/IWorkOrderCommentService.cs
@@ -0,0 +1,17 @@
+using Data.SeaHavenIndustries.Enums;
+using SeaHaven.Services.DTOs;
+
+namespace SeaHaven.Services.Interfaces
+{
+    public interface IWorkOrderCommentService
+    {
+        Task<IReadOnlyList<WorkOrderCommentDto>?> GetCommentsAsync(int workOrderId);
+        Task<WorkOrderCommentDto> AddCommentAsync(int workOrderId, WorkOrderCommentCreateDto request, string? actorId, string? documentUrl = null);
+        Task<WorkOrderCommentDto> UpdateCommentAsync(
+            int workOrderId,
+            int commentId,
+            WorkOrderCommentCreateDto request,
+            string? actorId,
+            bool isAdmin);
+    }
+}
diff --git a/SeaHaven.Services/Interfaces/IWorkOrderCompletionService.cs b/SeaHaven.Services/Interfaces/IWorkOrderCompletionService.cs
new file mode 100644
index 0000000..333e906
--- /dev/null
+++ b/SeaHaven.Services/Interfaces/IWorkOrderCompletionService.cs
@@ -0,0 +1,19 @@
+using Data.SeaHavenIndustries.Enums;
+using SeaHaven.Services.DTOs;
+
+namespace SeaHaven.Services.Interfaces
+{
+    public interface IWorkOrderCompletionService
+    {
+        Task<IReadOnlyList<CompletionDocTemplateDto>> GetTemplatesAsync(string? serviceKey, WorkOrderType? workOrderType);
+        Task<CompletionDocTemplateDto?> GetTemplateByIdAsync(int id);
+        Task<WorkOrderCompletionDto> UploadCompletionDocAsync(
+            int workOrderId,
+            WorkOrderCompletionDocUploadDto request,
+            string fileUrl,
+            string? actorId);
+        Task<CompletionDocTemplateDto> CreateTemplateAsync(CompletionDocTemplateCreateDto request);
+        Task<CompletionDocTemplateDto> UpdateTemplateAsync(int id, CompletionDocTemplateCreateDto request);
+        Task DeleteTemplateAsync(int id);
+    }
+}
diff --git a/SeaHaven.Services/Interfaces/IWorkOrderDetailService.cs b/SeaHaven.Services/Interfaces/IWorkOrderDetailService.cs
new file mode 100644
index 0000000..c59f968
--- /dev/null
+++ b/SeaHaven.Services/Interfaces/IWorkOrderDetailService.cs
@@ -0,0 +1,10 @@
+using SeaHaven.Services.DTOs;
+
+namespace SeaHaven.Services.Interfaces
+{
+    public interface IWorkOrderDetailService
+    {
+        Task<WorkOrderDetailDto?> GetDetailAsync(int workOrderId);
+        Task<IReadOnlyList<WorkOrderAuditEntryDto>?> GetAuditAsync(int workOrderId, int limit = 50);
+    }
+}
diff --git a/SeaHaven.Services/Interfaces/IWorkOrderFieldLockService.cs b/SeaHaven.Services/Interfaces/IWorkOrderFieldLockService.cs
new file mode 100644
index 0000000..2254724
--- /dev/null
+++ b/SeaHaven.Services/Interfaces/IWorkOrderFieldLockService.cs
@@ -0,0 +1,8 @@
+namespace SeaHaven.Services.Interfaces
+{
+    public interface IWorkOrderFieldLockService
+    {
+        Task LockFieldAsync(int workOrderId, string fieldName, string? userId);
+        Task<bool> IsLockedAsync(int workOrderId, string fieldName);
+    }
+}
diff --git a/SeaHaven.Services/Interfaces/IWorkOrderMediaService.cs b/SeaHaven.Services/Interfaces/IWorkOrderMediaService.cs
new file mode 100644
index 0000000..015cc83
--- /dev/null
+++ b/SeaHaven.Services/Interfaces/IWorkOrderMediaService.cs
@@ -0,0 +1,12 @@
+using Data.SeaHavenIndustries.Enums;
+using SeaHaven.Services.DTOs;
+
+namespace SeaHaven.Services.Interfaces
+{
+    public interface IWorkOrderMediaService
+    {
+        Task<IReadOnlyList<WorkOrderMediaFileDto>?> GetMediaAsync(int workOrderId);
+        Task<WorkOrderMediaFileDto> AddMediaAsync(int workOrderId, WorkOrderMediaCategory category, string fileUrl, string? actorId);
+        Task DeleteMediaAsync(int workOrderId, int mediaId, string? actorId);
+    }
+}
diff --git a/SeaHaven.Services/Interfaces/IWorkOrderPhase7Services.cs b/SeaHaven.Services/Interfaces/IWorkOrderPhase7Services.cs
new file mode 100644
index 0000000..0242a38
--- /dev/null
+++ b/SeaHaven.Services/Interfaces/IWorkOrderPhase7Services.cs
@@ -0,0 +1,16 @@
+using SeaHaven.Services.DTOs;
+
+namespace SeaHaven.Services.Interfaces
+{
+    public interface IWorkOrderIngestService
+    {
+        Task<WorkOrderIngestBatchResultDto> UpsertBatchAsync(
+            IReadOnlyList<WorkOrderIngestPayloadDto> items,
+            CancellationToken cancellationToken = default);
+    }
+
+    public interface IWorkOrderOpsHealthService
+    {
+        Task<WorkOrderOpsHealthDto> GetHealthAsync(CancellationToken cancellationToken = default);
+    }
+}
diff --git a/SeaHaven.Services/Interfaces/IWorkOrderWeekRolledService.cs b/SeaHaven.Services/Interfaces/IWorkOrderWeekRolledService.cs
new file mode 100644
index 0000000..b8c1a6a
--- /dev/null
+++ b/SeaHaven.Services/Interfaces/IWorkOrderWeekRolledService.cs
@@ -0,0 +1,11 @@
+using SeaHaven.Services.DTOs;
+
+namespace SeaHaven.Services.Interfaces
+{
+    public interface IWorkOrderWeekRolledService
+    {
+        Task<WeekRolledJobResult> ProcessWeekRolledAsync(
+            DateOnly sourceWeekStart,
+            CancellationToken cancellationToken = default);
+    }
+}
diff --git a/SeaHaven.Services/Validation/WorkOrderBoardCreateValidation.cs b/SeaHaven.Services/Validation/WorkOrderBoardCreateValidation.cs
new file mode 100644
index 0000000..8d0564d
--- /dev/null
+++ b/SeaHaven.Services/Validation/WorkOrderBoardCreateValidation.cs
@@ -0,0 +1,94 @@
+using FluentValidation;
+using SeaHaven.Services.DTOs;
+
+namespace SeaHaven.Services.Validation
+{
+    public interface IWorkOrderBoardCreateValidation : IValidator<WorkOrderBoardCreateRequestDto>
+    {
+    }
+
+    public class WorkOrderBoardCreateValidation : AbstractValidator<WorkOrderBoardCreateRequestDto>, IWorkOrderBoardCreateValidation
+    {
+        public WorkOrderBoardCreateValidation()
+        {
+            RuleFor(x => x.WorkOrderType)
+                .IsInEnum().WithMessage("workOrderType is required and must be a valid value.");
+
+            RuleFor(x => x.SiteCode)
+                .NotEmpty().WithMessage("siteCode is required.")
+                .MaximumLength(32);
+
+            RuleFor(x => x.TargetWeek)
+                .NotNull().WithMessage("targetWeek is required when scheduleWeekOnly is true.")
+                .When(x => x.ScheduleWeekOnly == true);
+
+            RuleFor(x => x.Description)
+                .MaximumLength(2000)
+                .When(x => !string.IsNullOrEmpty(x.Description));
+
+            RuleFor(x => x.Trade)
+                .MaximumLength(128)
+                .When(x => !string.IsNullOrEmpty(x.Trade));
+
+            RuleFor(x => x.PrimaryService)
+                .MaximumLength(128)
+                .When(x => !string.IsNullOrEmpty(x.PrimaryService));
+
+            RuleFor(x => x.ServiceNotes)
+                .MaximumLength(4000)
+                .When(x => !string.IsNullOrEmpty(x.ServiceNotes));
+
+            RuleFor(x => x.PocName)
+                .MaximumLength(200)
+                .When(x => !string.IsNullOrEmpty(x.PocName));
+
+            RuleFor(x => x.PocPhone)
+                .MaximumLength(50)
+                .When(x => !string.IsNullOrEmpty(x.PocPhone));
+
+            RuleFor(x => x.PocNotes)
+                .MaximumLength(2000)
+                .When(x => !string.IsNullOrEmpty(x.PocNotes));
+
+            RuleFor(x => x.TechPhone)
+                .MaximumLength(50)
+                .When(x => !string.IsNullOrEmpty(x.TechPhone));
+
+            RuleFor(x => x.VendorNotes)
+                .MaximumLength(2000)
+                .When(x => !string.IsNullOrEmpty(x.VendorNotes));
+
+            RuleFor(x => x.LocationId)
+                .GreaterThan(0)
+                .When(x => x.LocationId.HasValue);
+
+            RuleFor(x => x.VendorId)
+                .GreaterThan(0)
+                .When(x => x.VendorId.HasValue);
+
+            RuleFor(x => x.PocContactId)
+                .GreaterThan(0)
+                .When(x => x.PocContactId.HasValue);
+
+            RuleFor(x => x)
+                .Must(HasPrimaryWhenExtras)
+                .WithMessage("primaryService (or trade) is required when extraServices is provided.")
+                .WithName("extraServices");
+
+            RuleForEach(x => x.ExtraServices)
+                .MaximumLength(128)
+                .When(x => x.ExtraServices != null);
+        }
+
+        private static bool HasPrimaryWhenExtras(WorkOrderBoardCreateRequestDto request)
+        {
+            var hasExtras = request.ExtraServices != null
+                && request.ExtraServices.Any(s => !string.IsNullOrWhiteSpace(s));
+            if (!hasExtras)
+                return true;
+
+            return !string.IsNullOrWhiteSpace(request.PrimaryService)
+                || !string.IsNullOrWhiteSpace(request.Trade);
+        }
+    }
+}
diff --git a/SeaHavenIndustries.Tests/ConcurrencyExceptionFilterTests.cs b/SeaHavenIndustries.Tests/ConcurrencyExceptionFilterTests.cs
new file mode 100644
index 0000000..6ccfaf1
--- /dev/null
+++ b/SeaHavenIndustries.Tests/ConcurrencyExceptionFilterTests.cs
@@ -0,0 +1,50 @@
+using Api.SeaHavenIndustries.Filters;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Abstractions;
+using Microsoft.AspNetCore.Mvc.Filters;
+using Microsoft.AspNetCore.Routing;
+using Microsoft.EntityFrameworkCore;
+
+namespace SeaHavenIndustries.Tests;
+
+public class ConcurrencyExceptionFilterTests
+{
+    [Fact]
+    public void OnException_DbUpdateConcurrencyException_Returns409Conflict()
+    {
+        var filter = new ConcurrencyExceptionFilter();
+        var context = CreateExceptionContext(new DbUpdateConcurrencyException());
+
+        filter.OnException(context);
+
+        Assert.True(context.ExceptionHandled);
+        var result = Assert.IsType<ConflictObjectResult>(context.Result);
+        Assert.Equal(StatusCodes.Status409Conflict, result.StatusCode);
+    }
+
+    [Fact]
+    public void OnException_OtherException_DoesNotHandle()
+    {
+        var filter = new ConcurrencyExceptionFilter();
+        var context = CreateExceptionContext(new InvalidOperationException("other"));
+
+        filter.OnException(context);
+
+        Assert.False(context.ExceptionHandled);
+        Assert.Null(context.Result);
+    }
+
+    private static ExceptionContext CreateExceptionContext(Exception exception)
+    {
+        var actionContext = new ActionContext(
+            new DefaultHttpContext(),
+            new RouteData(),
+            new ActionDescriptor());
+
+        return new ExceptionContext(actionContext, [])
+        {
+            Exception = exception
+        };
+    }
+}
diff --git a/SeaHavenIndustries.Tests/LifecycleStatusMapperTests.cs b/SeaHavenIndustries.Tests/LifecycleStatusMapperTests.cs
new file mode 100644
index 0000000..0a06141
--- /dev/null
+++ b/SeaHavenIndustries.Tests/LifecycleStatusMapperTests.cs
@@ -0,0 +1,40 @@
+using Data.SeaHavenIndustries.Enums;
+using SeaHaven.Services.Constants;
+using SeaHaven.Services.Helpers;
+
+namespace SeaHavenIndustries.Tests;
+
+public class LifecycleStatusMapperTests
+{
+    [Theory]
+    [InlineData("Open", LifecycleStatus.Incomplete)]
+    [InlineData("Incomplete", LifecycleStatus.Incomplete)]
+    [InlineData("InProgress", LifecycleStatus.InProgress)]
+    [InlineData("In Progress", LifecycleStatus.InProgress)]
+    [InlineData("Completed", LifecycleStatus.Completed)]
+    [InlineData("Cancelled", LifecycleStatus.Canceled)]
+    [InlineData("On Hold", LifecycleStatus.Pending)]
+    [InlineData("Scheduled", LifecycleStatus.Scheduled)]
+    [InlineData("En Route", LifecycleStatus.EnRoute)]
+    [InlineData("Pending Quote", LifecycleStatus.PendingQuote)]
+    public void FromLegacyStatus_MapsKnownValues(string input, LifecycleStatus expected)
+    {
+        var result = LifecycleStatusMapper.FromLegacyStatus(input);
+        Assert.Equal(expected, result);
+    }
+
+    [Fact]
+    public void FromLegacyStatus_Unknown_ReturnsNull()
+    {
+        var result = LifecycleStatusMapper.FromLegacyStatus("MysteryStatus");
+        Assert.Null(result);
+    }
+
+    [Theory]
+    [InlineData(LifecycleStatus.EnRoute, "En Route")]
+    [InlineData(LifecycleStatus.PendingQuote, "Pending Quote")]
+    public void ToFeLabel_ReturnsBoardLabel(LifecycleStatus status, string expected)
+    {
+        Assert.Equal(expected, LifecycleStatusMapper.ToFeLabel(status));
+    }
+}
diff --git a/SeaHavenIndustries.Tests/SeaHavenIndustries.Tests.csproj b/SeaHavenIndustries.Tests/SeaHavenIndustries.Tests.csproj
new file mode 100644
index 0000000..2fc3613
--- /dev/null
+++ b/SeaHavenIndustries.Tests/SeaHavenIndustries.Tests.csproj
@@ -0,0 +1,29 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="6.0.2" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="8.0.8" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="8.0.8" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="xunit" Version="2.9.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Xunit" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Api.SeaHavenIndustries\Api.SeaHavenIndustries.csproj" />
+    <ProjectReference Include="..\SeaHaven.Services\SeaHaven.Services.csproj" />
+    <ProjectReference Include="..\Data.SeaHavenIndustries\Data.SeaHavenIndustries.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/SeaHavenIndustries.Tests/SyncFieldMergePolicyTests.cs b/SeaHavenIndustries.Tests/SyncFieldMergePolicyTests.cs
new file mode 100644
index 0000000..e9831d7
--- /dev/null
+++ b/SeaHavenIndustries.Tests/SyncFieldMergePolicyTests.cs
@@ -0,0 +1,151 @@
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+using Microsoft.EntityFrameworkCore;
+using SeaHaven.Services.Constants;
+using SeaHaven.Services.Implementation;
+using SeaHaven.Services.Interfaces;
+
+namespace SeaHavenIndustries.Tests;
+
+public class SyncFieldMergePolicyTests
+{
+    private static ApplicationDbContext CreateContext()
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+        return new ApplicationDbContext(options);
+    }
+
+    [Fact]
+    public async Task TryApply_WhenFieldLocked_RejectsAndAudits()
+    {
+        await using var context = CreateContext();
+        var wo = new WorkOrder { Id = 10, Description = "SHOC edited", Status = "Open" };
+        context.workOrders.Add(wo);
+        context.WorkOrderFieldLocks.Add(new WorkOrderFieldLock
+        {
+            WorkOrderId = 10,
+            FieldName = WorkOrderFieldNames.Description,
+            LockedAt = DateTime.UtcNow
+        });
+        await context.SaveChangesAsync();
+
+        var locks = new WorkOrderFieldLockService(context);
+        var audit = new WorkOrderAuditService(context, locks);
+        var policy = new SyncFieldMergePolicy(locks);
+
+        var syncContext = new WorkOrderSyncContext
+        {
+            WorkOrder = wo,
+            FieldLocks = locks,
+            Audit = audit
+        };
+
+        var applied = await policy.TryApplyAsync(syncContext, WorkOrderFieldNames.Description, "Sync value");
+
+        Assert.False(applied);
+        Assert.Equal("SHOC edited", wo.Description);
+
+        var logs = await context.WorkOrderAuditLogs.ToListAsync();
+        Assert.Single(logs);
+        Assert.Equal("SyncRejected", logs[0].Action);
+        Assert.Equal("Sync", logs[0].EventType);
+    }
+
+    [Fact]
+    public async Task TryApply_WhenFieldNotLocked_AppliesValue()
+    {
+        await using var context = CreateContext();
+        var wo = new WorkOrder { Id = 11, Description = "Original" };
+        context.workOrders.Add(wo);
+        await context.SaveChangesAsync();
+
+        var locks = new WorkOrderFieldLockService(context);
+        var audit = new WorkOrderAuditService(context, locks);
+        var policy = new SyncFieldMergePolicy(locks);
+
+        var syncContext = new WorkOrderSyncContext
+        {
+            WorkOrder = wo,
+            FieldLocks = locks,
+            Audit = audit
+        };
+
+        var applied = await policy.TryApplyAsync(syncContext, WorkOrderFieldNames.Description, "From sync");
+
+        Assert.True(applied);
+        Assert.Equal("From sync", wo.Description);
+    }
+
+    [Fact]
+    public async Task TryApply_UnsupportedField_ReturnsFalse()
+    {
+        await using var context = CreateContext();
+        var wo = new WorkOrder { Id = 12 };
+        context.workOrders.Add(wo);
+        await context.SaveChangesAsync();
+
+        var locks = new WorkOrderFieldLockService(context);
+        var audit = new WorkOrderAuditService(context, locks);
+        var policy = new SyncFieldMergePolicy(locks);
+
+        var syncContext = new WorkOrderSyncContext
+        {
+            WorkOrder = wo,
+            FieldLocks = locks,
+            Audit = audit
+        };
+
+        var applied = await policy.TryApplyAsync(syncContext, "NotARealField", "value");
+
+        Assert.False(applied);
+    }
+
+    [Theory]
+    [InlineData(WorkOrderFieldNames.LifecycleStatus, LifecycleStatus.Scheduled)]
+    [InlineData(WorkOrderFieldNames.Service, "PM")]
+    [InlineData(WorkOrderFieldNames.DueDate, "2026-07-01T10:00:00Z")]
+    public async Task TryApply_ShocOwnedFields_AppliesValue(string fieldName, object incomingValue)
+    {
+        await using var context = CreateContext();
+        var wo = new WorkOrder { Id = 13 };
+        context.workOrders.Add(wo);
+        await context.SaveChangesAsync();
+
+        var locks = new WorkOrderFieldLockService(context);
+        var audit = new WorkOrderAuditService(context, locks);
+        var policy = new SyncFieldMergePolicy(locks);
+
+        var syncContext = new WorkOrderSyncContext
+        {
+            WorkOrder = wo,
+            FieldLocks = locks,
+            Audit = audit
+        };
+
+        var applied = await policy.TryApplyAsync(syncContext, fieldName, incomingValue);
+
+        Assert.True(applied);
+    }
+
+    [Fact]
+    public async Task CanSyncOverwriteAsync_WhenLocked_ReturnsFalse()
+    {
+        await using var context = CreateContext();
+        context.WorkOrderFieldLocks.Add(new WorkOrderFieldLock
+        {
+            WorkOrderId = 20,
+            FieldName = WorkOrderFieldNames.AssignTo,
+            LockedAt = DateTime.UtcNow
+        });
+        await context.SaveChangesAsync();
+
+        var locks = new WorkOrderFieldLockService(context);
+        var policy = new SyncFieldMergePolicy(locks);
+
+        var canOverwrite = await policy.CanSyncOverwriteAsync(20, WorkOrderFieldNames.AssignTo);
+
+        Assert.False(canOverwrite);
+    }
+}
diff --git a/SeaHavenIndustries.Tests/WorkOrderAuditServiceTests.cs b/SeaHavenIndustries.Tests/WorkOrderAuditServiceTests.cs
new file mode 100644
index 0000000..f7df5ed
--- /dev/null
+++ b/SeaHavenIndustries.Tests/WorkOrderAuditServiceTests.cs
@@ -0,0 +1,56 @@
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+using Microsoft.EntityFrameworkCore;
+using SeaHaven.Services.Constants;
+using SeaHaven.Services.Implementation;
+using SeaHaven.Services.Interfaces;
+
+namespace SeaHavenIndustries.Tests;
+
+public class WorkOrderAuditServiceTests
+{
+    private static ApplicationDbContext CreateContext()
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+        return new ApplicationDbContext(options);
+    }
+
+    [Fact]
+    public async Task LogStatusChanged_CreatesSingleAuditWithManualEventType()
+    {
+        await using var context = CreateContext();
+        context.workOrders.Add(new WorkOrder { Id = 1, Status = "Open" });
+        await context.SaveChangesAsync();
+
+        var locks = new WorkOrderFieldLockService(context);
+        var audit = new WorkOrderAuditService(context, locks);
+
+        await audit.LogStatusChangedAsync(1, "Open", "In Progress", "user-1");
+
+        var logs = await context.WorkOrderAuditLogs.ToListAsync();
+        Assert.Single(logs);
+        Assert.Equal("StatusChanged", logs[0].Action);
+        Assert.Equal("Manual", logs[0].EventType);
+        Assert.Equal("Dispatcher", logs[0].ActorType);
+        Assert.Equal(WorkOrderFieldNames.LifecycleStatus, logs[0].FieldName);
+    }
+
+    [Fact]
+    public async Task LogStatusChanged_CreatesFieldLock()
+    {
+        await using var context = CreateContext();
+        context.workOrders.Add(new WorkOrder { Id = 2, Status = "Open" });
+        await context.SaveChangesAsync();
+
+        var locks = new WorkOrderFieldLockService(context);
+        var audit = new WorkOrderAuditService(context, locks);
+
+        await audit.LogStatusChangedAsync(2, "Open", "Scheduled", "user-1");
+
+        var fieldLocks = await context.WorkOrderFieldLocks.ToListAsync();
+        Assert.Single(fieldLocks);
+        Assert.Equal(WorkOrderFieldNames.LifecycleStatus, fieldLocks[0].FieldName);
+    }
+}
diff --git a/SeaHavenIndustries.Tests/WorkOrderBoardCancelServiceTests.cs b/SeaHavenIndustries.Tests/WorkOrderBoardCancelServiceTests.cs
new file mode 100644
index 0000000..cfb7874
--- /dev/null
+++ b/SeaHavenIndustries.Tests/WorkOrderBoardCancelServiceTests.cs
@@ -0,0 +1,151 @@
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+using Microsoft.EntityFrameworkCore;
+using SeaHaven.DataServices.Implementation;
+using SeaHaven.Services.Exceptions;
+using SeaHaven.Services.Helpers;
+using SeaHaven.Services.Implementation;
+
+namespace SeaHavenIndustries.Tests;
+
+public class WorkOrderBoardCancelServiceTests
+{
+    private static (ApplicationDbContext Context, WorkOrderBoardCancelService Cancel, WorkOrderBoardUpdateService Update) CreateSut()
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+        var context = new ApplicationDbContext(options);
+        var boardData = new WorkOrderBoardDataService(context);
+        var boardService = new WorkOrderBoardService(boardData);
+        var fieldLocks = new WorkOrderFieldLockService(context);
+        var audit = new WorkOrderAuditService(context, fieldLocks);
+        var cancel = new WorkOrderBoardCancelService(context, boardService, audit);
+        var update = new WorkOrderBoardUpdateService(context, boardData, audit);
+        return (context, cancel, update);
+    }
+
+    private static string ToVersion(WorkOrder workOrder)
+        => Convert.ToBase64String(workOrder.RowVersion ?? new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 });
+
+    [Fact]
+    public async Task Cancel_SetsLifecycleStatusCanceled()
+    {
+        var (context, cancel, _) = CreateSut();
+        var wo = new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Incomplete,
+            Status = "Incomplete",
+            SiteCode = "BK5",
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        };
+        context.workOrders.Add(wo);
+        await context.SaveChangesAsync();
+
+        var result = await cancel.CancelAsync(1, "actor-1");
+
+        Assert.Equal(LifecycleStatus.Canceled, result.LifecycleStatus);
+        Assert.Equal("Canceled", result.LifecycleStatusLabel);
+    }
+
+    [Fact]
+    public async Task Cancel_IsIdempotentWhenAlreadyCanceled()
+    {
+        var (context, cancel, _) = CreateSut();
+        var wo = new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Canceled,
+            Status = "Canceled",
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        };
+        context.workOrders.Add(wo);
+        await context.SaveChangesAsync();
+
+        var before = await context.WorkOrderAuditLogs.CountAsync();
+        var result = await cancel.CancelAsync(1, "actor-1");
+        var after = await context.WorkOrderAuditLogs.CountAsync();
+
+        Assert.Equal(LifecycleStatus.Canceled, result.LifecycleStatus);
+        Assert.Equal(before, after);
+    }
+
+    [Fact]
+    public async Task Cancel_BlocksWhenCompleted()
+    {
+        var (context, cancel, _) = CreateSut();
+        context.workOrders.Add(new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Completed,
+            Status = "Completed"
+        });
+        await context.SaveChangesAsync();
+
+        var ex = await Assert.ThrowsAsync<WorkOrderBoardValidationException>(() => cancel.CancelAsync(1, "actor-1"));
+        Assert.Equal("CancelNotAllowed", ex.Code);
+    }
+
+    [Fact]
+    public async Task Cancel_BlocksWhenClosedLabel()
+    {
+        var (context, cancel, _) = CreateSut();
+        context.workOrders.Add(new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Completed,
+            Status = "Closed"
+        });
+        await context.SaveChangesAsync();
+
+        var ex = await Assert.ThrowsAsync<WorkOrderBoardValidationException>(() => cancel.CancelAsync(1, "actor-1"));
+        Assert.Equal("CancelNotAllowed", ex.Code);
+    }
+
+    [Fact]
+    public async Task Cancel_WritesStatusChangedAudit()
+    {
+        var (context, cancel, _) = CreateSut();
+        context.workOrders.Add(new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Scheduled,
+            Status = "Scheduled",
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        });
+        await context.SaveChangesAsync();
+
+        await cancel.CancelAsync(1, "actor-1");
+
+        var log = await context.WorkOrderAuditLogs.SingleAsync(l => l.Action == "StatusChanged");
+        Assert.Equal("Canceled", log.NewValue);
+    }
+
+    [Fact]
+    public async Task Patch_AfterCancel_IsBlocked()
+    {
+        var (context, cancel, update) = CreateSut();
+        var wo = new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Incomplete,
+            Status = "Incomplete",
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        };
+        context.workOrders.Add(wo);
+        await context.SaveChangesAsync();
+
+        await cancel.CancelAsync(1, "actor-1");
+
+        var ex = await Assert.ThrowsAsync<WorkOrderBoardValidationException>(() =>
+            update.PatchFieldAsync(1, new SeaHaven.Services.DTOs.WorkOrderBoardPatchRequestDto
+            {
+                Field = WorkOrderBoardFieldNames.SiteCode,
+                Value = "NEW",
+                WorkOrderVersion = ToVersion(wo)
+            }, "actor-1"));
+
+        Assert.Equal("CanceledReadOnly", ex.Code);
+    }
+}
diff --git a/SeaHavenIndustries.Tests/WorkOrderBoardConcurrencyTests.cs b/SeaHavenIndustries.Tests/WorkOrderBoardConcurrencyTests.cs
new file mode 100644
index 0000000..7039963
--- /dev/null
+++ b/SeaHavenIndustries.Tests/WorkOrderBoardConcurrencyTests.cs
@@ -0,0 +1,184 @@
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+using Microsoft.EntityFrameworkCore;
+using SeaHaven.DataServices.Implementation;
+using SeaHaven.Services.DTOs;
+using SeaHaven.Services.Exceptions;
+using SeaHaven.Services.Helpers;
+using SeaHaven.Services.Implementation;
+
+namespace SeaHavenIndustries.Tests;
+
+public class WorkOrderBoardConcurrencyTests
+{
+    private static ApplicationDbContext CreateContext(string dbName)
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(dbName)
+            .Options;
+        return new ApplicationDbContext(options);
+    }
+
+    private static WorkOrderBoardUpdateService CreateService(ApplicationDbContext context)
+    {
+        var boardData = new WorkOrderBoardDataService(context);
+        var fieldLocks = new WorkOrderFieldLockService(context);
+        var audit = new WorkOrderAuditService(context, fieldLocks);
+        return new WorkOrderBoardUpdateService(context, boardData, audit);
+    }
+
+    [Fact]
+    public async Task ParallelVendorAndStatusEdits_OnDifferentAggregates_Succeed()
+    {
+        var dbName = Guid.NewGuid().ToString();
+        await using var seedContext = CreateContext(dbName);
+        seedContext.Vendors.Add(new Vendor { Id = 3, CompanyName = "Parallel Vendor" });
+        var dispatch = new Dispatch
+        {
+            Id = 10,
+            VendorId = 3,
+            WorkOrderId = 1,
+            RowVersion = new byte[] { 9, 0, 0, 0, 0, 0, 0, 9 }
+        };
+        seedContext.Dispatches.Add(dispatch);
+        seedContext.workOrders.Add(new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Incomplete,
+            PrimaryDispatchId = 10,
+            RowVersion = new byte[] { 8, 0, 0, 0, 0, 0, 0, 8 }
+        });
+        await seedContext.SaveChangesAsync();
+
+        await using var woContext = CreateContext(dbName);
+        await using var dispatchContext = CreateContext(dbName);
+        var woService = CreateService(woContext);
+        var dispatchService = CreateService(dispatchContext);
+
+        var wo = await woContext.workOrders.FindAsync(1);
+        var disp = await dispatchContext.Dispatches.FindAsync(10);
+
+        var statusTask = woService.PatchFieldAsync(1, new WorkOrderBoardPatchRequestDto
+        {
+            Field = WorkOrderBoardFieldNames.LifecycleStatus,
+            Value = "Scheduled",
+            WorkOrderVersion = Convert.ToBase64String(wo!.RowVersion!)
+        }, "dispatcher-a");
+
+        var vendorTask = dispatchService.PatchFieldAsync(1, new WorkOrderBoardPatchRequestDto
+        {
+            Field = WorkOrderBoardFieldNames.VendorId,
+            Value = "3",
+            WorkOrderVersion = Convert.ToBase64String(wo.RowVersion!),
+            DispatchVersion = Convert.ToBase64String(disp!.RowVersion!),
+            PrimaryDispatchId = 10
+        }, "dispatcher-b");
+
+        await Task.WhenAll(statusTask, vendorTask);
+
+        Assert.Equal(LifecycleStatus.Scheduled, statusTask.Result.LifecycleStatus);
+        Assert.Equal(3, vendorTask.Result.VendorId);
+    }
+
+    [Fact]
+    public async Task StaleWorkOrderVersion_ThrowsConcurrencyWithCurrentState()
+    {
+        var dbName = Guid.NewGuid().ToString();
+        await using var context1 = CreateContext(dbName);
+        context1.workOrders.Add(new WorkOrder
+        {
+            Id = 1,
+            SiteCode = "A",
+            LifecycleStatus = LifecycleStatus.Scheduled,
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        });
+        await context1.SaveChangesAsync();
+
+        await using var context2 = CreateContext(dbName);
+        var wo2 = await context2.workOrders.FirstAsync();
+        wo2.SiteCode = "B";
+        await context2.SaveChangesAsync();
+
+        await using var patchContext = CreateContext(dbName);
+        var service = CreateService(patchContext);
+        var staleVersion = Convert.ToBase64String(new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 });
+
+        var ex = await Assert.ThrowsAsync<WorkOrderBoardConcurrencyException>(() =>
+            service.PatchFieldAsync(1, new WorkOrderBoardPatchRequestDto
+            {
+                Field = WorkOrderBoardFieldNames.SiteCode,
+                Value = "C",
+                WorkOrderVersion = staleVersion
+            }, "actor-1"));
+
+        Assert.NotNull(ex.CurrentState);
+        Assert.Equal("B", ex.CurrentState!.SiteCode);
+    }
+
+    [Fact]
+    public async Task RescheduleAuditCount_MatchesChangedFields()
+    {
+        var dbName = Guid.NewGuid().ToString();
+        await using var context = CreateContext(dbName);
+        context.workOrders.Add(new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Scheduled,
+            ScheduledDate = new DateTime(2026, 6, 20),
+            RescheduleCount = 0,
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        });
+        await context.SaveChangesAsync();
+
+        var service = CreateService(context);
+        var wo = await context.workOrders.FindAsync(1);
+
+        await service.PatchFieldAsync(1, new WorkOrderBoardPatchRequestDto
+        {
+            Field = WorkOrderBoardFieldNames.ScheduledDate,
+            Value = "2026-06-25",
+            WorkOrderVersion = Convert.ToBase64String(wo!.RowVersion!)
+        }, "actor-1");
+
+        var auditCount = await context.WorkOrderAuditLogs.CountAsync();
+        Assert.Equal(2, auditCount);
+    }
+
+    [Fact]
+    public async Task SecondEditWithStaleVersion_FailsAfterFirstEdit()
+    {
+        var dbName = Guid.NewGuid().ToString();
+        await using var seed = CreateContext(dbName);
+        seed.workOrders.Add(new WorkOrder
+        {
+            Id = 1,
+            SiteCode = "A",
+            LifecycleStatus = LifecycleStatus.Scheduled,
+            RowVersion = new byte[] { 4, 0, 0, 0, 0, 0, 0, 4 }
+        });
+        await seed.SaveChangesAsync();
+
+        var originalVersion = Convert.ToBase64String(new byte[] { 4, 0, 0, 0, 0, 0, 0, 4 });
+
+        await using (var ctx1 = CreateContext(dbName))
+        {
+            var svc1 = CreateService(ctx1);
+            await svc1.PatchFieldAsync(1, new WorkOrderBoardPatchRequestDto
+            {
+                Field = WorkOrderBoardFieldNames.SiteCode,
+                Value = "B",
+                WorkOrderVersion = originalVersion
+            }, "user-1");
+        }
+
+        await using var ctx2 = CreateContext(dbName);
+        var svc2 = CreateService(ctx2);
+        await Assert.ThrowsAsync<WorkOrderBoardConcurrencyException>(() =>
+            svc2.PatchFieldAsync(1, new WorkOrderBoardPatchRequestDto
+            {
+                Field = WorkOrderBoardFieldNames.SiteCode,
+                Value = "C",
+                WorkOrderVersion = originalVersion
+            }, "user-2"));
+    }
+}
diff --git a/SeaHavenIndustries.Tests/WorkOrderBoardCreateRelationalTests.cs b/SeaHavenIndustries.Tests/WorkOrderBoardCreateRelationalTests.cs
new file mode 100644
index 0000000..2873689
--- /dev/null
+++ b/SeaHavenIndustries.Tests/WorkOrderBoardCreateRelationalTests.cs
@@ -0,0 +1,97 @@
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+using SeaHaven.DataServices.Implementation;
+using SeaHaven.Services.DTOs;
+using SeaHaven.Services.Implementation;
+using SeaHaven.Services.Validation;
+
+namespace SeaHavenIndustries.Tests;
+
+public class WorkOrderBoardCreateRelationalTests
+{
+    [Fact]
+    public async Task Create_AuditAndFieldLocks_UseGeneratedWorkOrderId()
+    {
+        await using var connection = new SqliteConnection("DataSource=:memory:");
+        await connection.OpenAsync();
+
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseSqlite(connection)
+            .Options;
+
+        await using var context = new SqliteBoardTestDbContext(options);
+        await context.Database.EnsureCreatedAsync();
+
+        const string actorId = "actor-1";
+        context.Users.Add(new ApplicationUser
+        {
+            Id = actorId,
+            UserName = "actor-1",
+            NormalizedUserName = "ACTOR-1",
+            Email = "actor@test.local",
+            NormalizedEmail = "ACTOR@TEST.LOCAL"
+        });
+        await context.SaveChangesAsync();
+
+        var boardData = new WorkOrderBoardDataService(context);
+        var boardService = new WorkOrderBoardService(boardData);
+        var fieldLocks = new WorkOrderFieldLockService(context);
+        var audit = new WorkOrderAuditService(context, fieldLocks);
+        var service = new WorkOrderBoardCreateService(
+            context,
+            boardData,
+            boardService,
+            audit,
+            new WorkOrderBoardCreateValidation());
+
+        var result = await service.CreateAsync(new WorkOrderBoardCreateRequestDto
+        {
+            WorkOrderType = WorkOrderType.PM,
+            SiteCode = "BK5",
+            Description = "Relational create"
+        }, actorId);
+
+        Assert.True(result.Id > 0);
+
+        var logs = await context.WorkOrderAuditLogs.AsNoTracking().ToListAsync();
+        var locks = await context.WorkOrderFieldLocks.AsNoTracking().ToListAsync();
+
+        Assert.NotEmpty(logs);
+        Assert.NotEmpty(locks);
+        Assert.Contains(logs, l => l.Action == "Create");
+        Assert.All(logs, l => Assert.Equal(result.Id, l.WorkOrderId));
+        Assert.All(locks, l => Assert.Equal(result.Id, l.WorkOrderId));
+        Assert.DoesNotContain(logs, l => l.WorkOrderId == 0);
+        Assert.DoesNotContain(locks, l => l.WorkOrderId == 0);
+    }
+
+    private sealed class SqliteBoardTestDbContext : ApplicationDbContext
+    {
+        public SqliteBoardTestDbContext(DbContextOptions<ApplicationDbContext> options)
+            : base(options)
+        {
+        }
+
+        protected override void OnModelCreating(ModelBuilder builder)
+        {
+            base.OnModelCreating(builder);
+
+            // SQL Server filtered index syntax is invalid on SQLite.
+            foreach (var index in builder.Model.GetEntityTypes().SelectMany(e => e.GetIndexes()))
+            {
+                if (index.GetFilter() != null)
+                    index.SetFilter(null);
+            }
+
+            // SQLite has no rowversion type; treat as plain nullable blobs.
+            foreach (var entityType in new[] { typeof(WorkOrder), typeof(Dispatch) })
+            {
+                var property = builder.Entity(entityType).Property("RowVersion").Metadata;
+                property.ValueGenerated = Microsoft.EntityFrameworkCore.Metadata.ValueGenerated.Never;
+                property.IsConcurrencyToken = false;
+            }
+        }
+    }
+}
diff --git a/SeaHavenIndustries.Tests/WorkOrderBoardCreateServiceTests.cs b/SeaHavenIndustries.Tests/WorkOrderBoardCreateServiceTests.cs
new file mode 100644
index 0000000..b3171f2
--- /dev/null
+++ b/SeaHavenIndustries.Tests/WorkOrderBoardCreateServiceTests.cs
@@ -0,0 +1,352 @@
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+using Microsoft.EntityFrameworkCore;
+using SeaHaven.DataServices.Implementation;
+using SeaHaven.Services.DTOs;
+using SeaHaven.Services.Exceptions;
+using SeaHaven.Services.Implementation;
+using SeaHaven.Services.Validation;
+
+namespace SeaHavenIndustries.Tests;
+
+public class WorkOrderBoardCreateServiceTests
+{
+    private static (ApplicationDbContext Context, WorkOrderBoardCreateService Service) CreateSut()
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+        var context = new ApplicationDbContext(options);
+        var boardData = new WorkOrderBoardDataService(context);
+        var boardService = new WorkOrderBoardService(boardData);
+        var fieldLocks = new WorkOrderFieldLockService(context);
+        var audit = new WorkOrderAuditService(context, fieldLocks);
+        var validator = new WorkOrderBoardCreateValidation();
+        var service = new WorkOrderBoardCreateService(context, boardData, boardService, audit, validator);
+        return (context, service);
+    }
+
+    [Fact]
+    public async Task Create_Minimal_ReturnsIncomplete()
+    {
+        var (_, service) = CreateSut();
+
+        var result = await service.CreateAsync(new WorkOrderBoardCreateRequestDto
+        {
+            WorkOrderType = WorkOrderType.PM,
+            SiteCode = "BK5"
+        }, "actor-1");
+
+        Assert.Equal(LifecycleStatus.Incomplete, result.LifecycleStatus);
+        Assert.Equal("BK5", result.SiteCode);
+        Assert.Equal(WorkOrderType.PM, result.WorkOrderType);
+        Assert.False(string.IsNullOrWhiteSpace(result.WoNumber));
+        Assert.Equal(11, result.WoNumber!.Length);
+    }
+
+    [Fact]
+    public async Task Create_WithManualWoNumber_NormalizesTo11Digits()
+    {
+        var (_, service) = CreateSut();
+
+        var result = await service.CreateAsync(new WorkOrderBoardCreateRequestDto
+        {
+            WoNumber = "12345",
+            WorkOrderType = WorkOrderType.PO,
+            SiteCode = "DAL"
+        }, "actor-1");
+
+        Assert.Equal("00000012345", result.WoNumber);
+    }
+
+    [Fact]
+    public async Task Create_DuplicateWoNumber_Throws()
+    {
+        var (context, service) = CreateSut();
+        context.workOrders.Add(new WorkOrder { InternalWONumber = "00000099999", WorkerOrderNumber = "00000099999" });
+        await context.SaveChangesAsync();
+
+        var ex = await Assert.ThrowsAsync<WorkOrderBoardValidationException>(() =>
+            service.CreateAsync(new WorkOrderBoardCreateRequestDto
+            {
+                WoNumber = "99999",
+                WorkOrderType = WorkOrderType.PM,
+                SiteCode = "BK5"
+            }, "actor-1"));
+
+        Assert.Equal("DuplicateWoNumber", ex.Code);
+    }
+
+    [Fact]
+    public async Task Create_AutoSchedulesWhenDateAndAssignee()
+    {
+        var (_, service) = CreateSut();
+
+        var result = await service.CreateAsync(new WorkOrderBoardCreateRequestDto
+        {
+            WorkOrderType = WorkOrderType.PM,
+            SiteCode = "BK5",
+            AssignTo = "dispatcher-1",
+            ScheduledDate = new DateTime(2026, 6, 25)
+        }, "actor-1");
+
+        Assert.Equal(LifecycleStatus.Scheduled, result.LifecycleStatus);
+        Assert.Equal(new DateTime(2026, 6, 25), result.ScheduledDate);
+    }
+
+    [Fact]
+    public async Task Create_WeekOnlyScheduling_SetsTargetWeek()
+    {
+        var (_, service) = CreateSut();
+
+        var result = await service.CreateAsync(new WorkOrderBoardCreateRequestDto
+        {
+            WorkOrderType = WorkOrderType.PM,
+            SiteCode = "BK5",
+            ScheduleWeekOnly = true,
+            TargetWeek = new DateOnly(2026, 6, 22)
+        }, "actor-1");
+
+        Assert.True(result.ScheduleWeekOnly);
+        Assert.Equal(new DateOnly(2026, 6, 22), result.TargetWeek);
+    }
+
+    [Fact]
+    public async Task Create_WeekOnlyWithoutTargetWeek_ThrowsValidation()
+    {
+        var (_, service) = CreateSut();
+
+        await Assert.ThrowsAsync<FluentValidation.ValidationException>(() =>
+            service.CreateAsync(new WorkOrderBoardCreateRequestDto
+            {
+                WorkOrderType = WorkOrderType.PM,
+                SiteCode = "BK5",
+                ScheduleWeekOnly = true
+            }, "actor-1"));
+    }
+
+    [Fact]
+    public async Task Create_WithVendor_CreatesPrimaryDispatch()
+    {
+        var (context, service) = CreateSut();
+        context.Vendors.Add(new Vendor { Id = 5, CompanyName = "Acme HVAC" });
+        await context.SaveChangesAsync();
+
+        var result = await service.CreateAsync(new WorkOrderBoardCreateRequestDto
+        {
+            WorkOrderType = WorkOrderType.PM,
+            SiteCode = "BK5",
+            VendorId = 5,
+            ApptDate = new DateTime(2026, 6, 26)
+        }, "actor-1");
+
+        Assert.Equal(5, result.VendorId);
+        Assert.NotNull(result.PrimaryDispatchId);
+    }
+
+    [Fact]
+    public async Task Create_CreatesFieldLocksForPopulatedFields()
+    {
+        var (context, service) = CreateSut();
+
+        var result = await service.CreateAsync(new WorkOrderBoardCreateRequestDto
+        {
+            WorkOrderType = WorkOrderType.PM,
+            SiteCode = "BK5",
+            Description = "Test WO"
+        }, "actor-1");
+
+        var locks = await context.WorkOrderFieldLocks.ToListAsync();
+        Assert.Contains(locks, l => l.FieldName == "SiteCode");
+        Assert.Contains(locks, l => l.FieldName == "WorkOrderType");
+        Assert.Contains(locks, l => l.FieldName == "Description");
+        Assert.All(locks, l => Assert.Equal(result.Id, l.WorkOrderId));
+    }
+
+    [Fact]
+    public async Task Create_WritesCreateAuditEvent()
+    {
+        var (context, service) = CreateSut();
+
+        var result = await service.CreateAsync(new WorkOrderBoardCreateRequestDto
+        {
+            WorkOrderType = WorkOrderType.PM,
+            SiteCode = "BK5"
+        }, "actor-1");
+
+        var logs = await context.WorkOrderAuditLogs.ToListAsync();
+        Assert.Contains(logs, l => l.Action == "Create");
+        Assert.Contains(logs, l => l.Action == "FieldChanged" && l.FieldName == "SiteCode");
+        Assert.All(logs, l => Assert.Equal(result.Id, l.WorkOrderId));
+        Assert.True(result.Id > 0);
+    }
+
+    [Fact]
+    public async Task Create_StructuredServiceNotes_PersistsAndReturnsPm()
+    {
+        var (context, service) = CreateSut();
+
+        var result = await service.CreateAsync(new WorkOrderBoardCreateRequestDto
+        {
+            WorkOrderType = WorkOrderType.PM,
+            SiteCode = "BK5",
+            PrimaryService = "HVAC PM",
+            ExtraServices = new List<string> { "Filter change", "Coil clean", "Filter change" },
+            ServiceNotes = "Unit on roof"
+        }, "actor-1");
+
+        Assert.Equal("HVAC PM", result.Pm);
+        Assert.Equal("Unit on roof", result.ServiceNotes);
+        Assert.Equal(new[] { "Filter change", "Coil clean" }, result.ExtraServices);
+
+        var wo = await context.workOrders.SingleAsync(w => w.Id == result.Id);
+        Assert.Equal("HVAC PM", wo.Trade);
+        Assert.Equal("Unit on roof", wo.ServiceNotes);
+        Assert.Contains("Filter change", wo.ExtraServices);
+        Assert.Contains("Coil clean", wo.ExtraServices);
+        Assert.Equal(1, System.Text.Json.JsonSerializer.Deserialize<List<string>>(wo.ExtraServices!)!
+            .Count(s => s == "Filter change"));
+    }
+
+    [Fact]
+    public async Task Create_PrimaryServiceTakesPrecedenceOverTrade()
+    {
+        var (_, service) = CreateSut();
+
+        var result = await service.CreateAsync(new WorkOrderBoardCreateRequestDto
+        {
+            WorkOrderType = WorkOrderType.Reactive,
+            SiteCode = "CHI",
+            Trade = "Legacy Trade",
+            PrimaryService = "Plumbing"
+        }, "actor-1");
+
+        Assert.Equal("Plumbing", result.Pm);
+    }
+
+    [Fact]
+    public async Task Create_ExtraServicesWithoutPrimary_ThrowsValidation()
+    {
+        var (_, service) = CreateSut();
+
+        await Assert.ThrowsAsync<FluentValidation.ValidationException>(() =>
+            service.CreateAsync(new WorkOrderBoardCreateRequestDto
+            {
+                WorkOrderType = WorkOrderType.PM,
+                SiteCode = "BK5",
+                ExtraServices = new List<string> { "Filter change" }
+            }, "actor-1"));
+    }
+
+    [Fact]
+    public async Task Create_PocFreeText_WithoutContact_AppearsOnBoardRow()
+    {
+        var (context, service) = CreateSut();
+
+        var result = await service.CreateAsync(new WorkOrderBoardCreateRequestDto
+        {
+            WorkOrderType = WorkOrderType.Reactive,
+            SiteCode = "BK5",
+            PocName = "Jane Site Lead",
+            PocPhone = "+1 555-0100",
+            PocNotes = "Call 30 min before"
+        }, "actor-1");
+
+        Assert.Equal("Jane Site Lead", result.PocName);
+        Assert.Equal("+1 555-0100", result.PocPhone);
+        Assert.Equal("Call 30 min before", result.PocNotes);
+
+        var wo = await context.workOrders.SingleAsync(w => w.Id == result.Id);
+        Assert.Equal("Jane Site Lead", wo.PocName);
+        Assert.Empty(context.WorkOrderContacts);
+    }
+
+    [Fact]
+    public async Task Create_WithoutVendor_PersistsTechPhoneAndVendorNotesOnWorkOrder()
+    {
+        var (context, service) = CreateSut();
+
+        var result = await service.CreateAsync(new WorkOrderBoardCreateRequestDto
+        {
+            WorkOrderType = WorkOrderType.PM,
+            SiteCode = "BK5",
+            TechPhone = "+1 555-0199",
+            VendorNotes = "Gate code 4421"
+        }, "actor-1");
+
+        Assert.Equal("+1 555-0199", result.TechPhone);
+
+        var wo = await context.workOrders.SingleAsync(w => w.Id == result.Id);
+        Assert.Equal("+1 555-0199", wo.TechPhone);
+        Assert.Equal("Gate code 4421", wo.VendorNotes);
+        Assert.Null(wo.PrimaryDispatchId);
+    }
+
+    [Fact]
+    public async Task Create_WithVendor_PersistsTechPhoneAndVendorNotesOnDispatch()
+    {
+        var (context, service) = CreateSut();
+        context.Vendors.Add(new Vendor { Id = 55, CompanyName = "Acme", Phone = "+1 555-0000" });
+        await context.SaveChangesAsync();
+
+        var result = await service.CreateAsync(new WorkOrderBoardCreateRequestDto
+        {
+            WorkOrderType = WorkOrderType.PM,
+            SiteCode = "BK5",
+            VendorId = 55,
+            ApptDate = new DateTime(2026, 7, 18),
+            TechPhone = "+1 555-0199",
+            VendorNotes = "Park behind dock"
+        }, "actor-1");
+
+        Assert.Equal("+1 555-0199", result.TechPhone);
+        Assert.Equal(55, result.VendorId);
+
+        var wo = await context.workOrders.Include(w => w.PrimaryDispatch).SingleAsync(w => w.Id == result.Id);
+        Assert.Null(wo.TechPhone);
+        Assert.Null(wo.VendorNotes);
+        Assert.NotNull(wo.PrimaryDispatch);
+        Assert.Equal("+1 555-0199", wo.PrimaryDispatch!.TechPhone);
+        Assert.Equal("Park behind dock", wo.PrimaryDispatch.VendorNotes);
+    }
+
+    [Fact]
+    public async Task Create_LegacyTradeAndDescription_StillWorks()
+    {
+        var (context, service) = CreateSut();
+
+        var result = await service.CreateAsync(new WorkOrderBoardCreateRequestDto
+        {
+            WorkOrderType = WorkOrderType.PM,
+            SiteCode = "BK5",
+            Trade = "HVAC",
+            Description = "pmNote\nPOC: Jane · +1 555\nVendor notes: gate"
+        }, "actor-1");
+
+        Assert.Equal("HVAC", result.Pm);
+        Assert.Null(result.PocName);
+
+        var wo = await context.workOrders.SingleAsync(w => w.Id == result.Id);
+        Assert.Equal("HVAC", wo.Trade);
+        Assert.Contains("Vendor notes:", wo.Description);
+        Assert.Null(wo.PocName);
+        Assert.Null(wo.ExtraServices);
+        Assert.Null(wo.ServiceNotes);
+    }
+
+    [Fact]
+    public async Task Create_UnknownVendorId_Throws()
+    {
+        var (_, service) = CreateSut();
+
+        var ex = await Assert.ThrowsAsync<WorkOrderBoardValidationException>(() =>
+            service.CreateAsync(new WorkOrderBoardCreateRequestDto
+            {
+                WorkOrderType = WorkOrderType.PM,
+                SiteCode = "BK5",
+                VendorId = 999
+            }, "actor-1"));
+
+        Assert.Equal("VendorNotFound", ex.Code);
+    }
+}
diff --git a/SeaHavenIndustries.Tests/WorkOrderBoardCreateSyncLockTests.cs b/SeaHavenIndustries.Tests/WorkOrderBoardCreateSyncLockTests.cs
new file mode 100644
index 0000000..6abde14
--- /dev/null
+++ b/SeaHavenIndustries.Tests/WorkOrderBoardCreateSyncLockTests.cs
@@ -0,0 +1,101 @@
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+using Microsoft.EntityFrameworkCore;
+using SeaHaven.DataServices.Implementation;
+using SeaHaven.Services.DTOs;
+using SeaHaven.Services.Implementation;
+using SeaHaven.Services.Interfaces;
+using SeaHaven.Services.Validation;
+
+namespace SeaHavenIndustries.Tests;
+
+public class WorkOrderBoardCreateSyncLockTests
+{
+    [Fact]
+    public async Task AfterShocCreate_SyncRejectsLockedSiteCode()
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+        await using var context = new ApplicationDbContext(options);
+
+        var boardData = new WorkOrderBoardDataService(context);
+        var boardService = new WorkOrderBoardService(boardData);
+        var fieldLocks = new WorkOrderFieldLockService(context);
+        var audit = new WorkOrderAuditService(context, fieldLocks);
+        var createService = new WorkOrderBoardCreateService(
+            context,
+            boardData,
+            boardService,
+            audit,
+            new WorkOrderBoardCreateValidation());
+        var policy = new SyncFieldMergePolicy(fieldLocks);
+
+        await createService.CreateAsync(new WorkOrderBoardCreateRequestDto
+        {
+            WorkOrderType = WorkOrderType.PM,
+            SiteCode = "BK5"
+        }, "dispatcher-1");
+
+        var wo = await context.workOrders.SingleAsync();
+        var syncContext = new WorkOrderSyncContext
+        {
+            WorkOrder = wo,
+            FieldLocks = fieldLocks,
+            Audit = audit
+        };
+
+        var applied = await policy.TryApplyAsync(syncContext, "SiteCode", "SYNC-SITE");
+
+        Assert.False(applied);
+        Assert.Equal("BK5", wo.SiteCode);
+
+        var rejected = await context.WorkOrderAuditLogs
+            .SingleAsync(l => l.Action == "SyncRejected" && l.FieldName == "SiteCode");
+        Assert.Equal("SYNC-SITE", rejected.NewValue);
+    }
+
+    [Fact]
+    public async Task AfterShocCreate_SyncCanUpdateUnlockedField_NotInShocSet()
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+        await using var context = new ApplicationDbContext(options);
+
+        var boardData = new WorkOrderBoardDataService(context);
+        var boardService = new WorkOrderBoardService(boardData);
+        var fieldLocks = new WorkOrderFieldLockService(context);
+        var audit = new WorkOrderAuditService(context, fieldLocks);
+        var createService = new WorkOrderBoardCreateService(
+            context,
+            boardData,
+            boardService,
+            audit,
+            new WorkOrderBoardCreateValidation());
+        var policy = new SyncFieldMergePolicy(fieldLocks);
+
+        await createService.CreateAsync(new WorkOrderBoardCreateRequestDto
+        {
+            WorkOrderType = WorkOrderType.PM,
+            SiteCode = "BK5"
+        }, "dispatcher-1");
+
+        var wo = await context.workOrders.SingleAsync();
+        wo.Customer = "Original";
+        await context.SaveChangesAsync();
+
+        var syncContext = new WorkOrderSyncContext
+        {
+            WorkOrder = wo,
+            FieldLocks = fieldLocks,
+            Audit = audit
+        };
+
+        // Customer is not in SyncFieldMergePolicy apply switch — use Description which wasn't set on create
+        var applied = await policy.TryApplyAsync(syncContext, "Description", "From sync");
+
+        Assert.True(applied);
+        Assert.Equal("From sync", wo.Description);
+    }
+}
diff --git a/SeaHavenIndustries.Tests/WorkOrderBoardMutationRulesTests.cs b/SeaHavenIndustries.Tests/WorkOrderBoardMutationRulesTests.cs
new file mode 100644
index 0000000..34509ce
--- /dev/null
+++ b/SeaHavenIndustries.Tests/WorkOrderBoardMutationRulesTests.cs
@@ -0,0 +1,55 @@
+using Data.SeaHavenIndustries.Enums;
+using SeaHaven.Services.Helpers;
+
+namespace SeaHavenIndustries.Tests;
+
+public class WorkOrderBoardMutationRulesTests
+{
+    [Theory]
+    [InlineData(LifecycleStatus.Canceled, true)]
+    [InlineData(LifecycleStatus.Completed, true)]
+    [InlineData(LifecycleStatus.Scheduled, false)]
+    [InlineData(LifecycleStatus.Incomplete, false)]
+    public void IsReadOnly_ReflectsTerminalStatuses(LifecycleStatus status, bool expected)
+    {
+        Assert.Equal(expected, WorkOrderBoardMutationRules.IsReadOnly(status));
+    }
+
+    [Fact]
+    public void ShouldBlockStatusChangeWhenPastDue_BlocksOnlyLifecycleStatus()
+    {
+        Assert.True(WorkOrderBoardMutationRules.ShouldBlockStatusChangeWhenPastDue(
+            WorkOrderBoardFieldNames.LifecycleStatus, isPastDue: true));
+        Assert.False(WorkOrderBoardMutationRules.ShouldBlockStatusChangeWhenPastDue(
+            WorkOrderBoardFieldNames.ScheduledDate, isPastDue: true));
+    }
+
+    [Fact]
+    public void ShouldAutoSchedule_WhenIncompleteWithDateAndAssignee()
+    {
+        Assert.True(WorkOrderBoardMutationRules.ShouldAutoSchedule(
+            LifecycleStatus.Incomplete,
+            new DateTime(2026, 6, 25),
+            "dispatcher-1"));
+    }
+
+    [Fact]
+    public void ShouldAutoSchedule_FalseWhenAlreadyScheduled()
+    {
+        Assert.False(WorkOrderBoardMutationRules.ShouldAutoSchedule(
+            LifecycleStatus.Scheduled,
+            new DateTime(2026, 6, 25),
+            "dispatcher-1"));
+    }
+
+    [Fact]
+    public void IsReschedule_WhenPreviousDateExistsAndChanges()
+    {
+        Assert.True(WorkOrderBoardMutationRules.IsReschedule(
+            new DateTime(2026, 6, 20),
+            new DateTime(2026, 6, 25)));
+        Assert.False(WorkOrderBoardMutationRules.IsReschedule(
+            null,
+            new DateTime(2026, 6, 25)));
+    }
+}
diff --git a/SeaHavenIndustries.Tests/WorkOrderBoardSearchTests.cs b/SeaHavenIndustries.Tests/WorkOrderBoardSearchTests.cs
new file mode 100644
index 0000000..7580562
--- /dev/null
+++ b/SeaHavenIndustries.Tests/WorkOrderBoardSearchTests.cs
@@ -0,0 +1,386 @@
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+using Microsoft.EntityFrameworkCore;
+using SeaHaven.DataServices.Helpers;
+using SeaHaven.DataServices.Implementation;
+
+namespace SeaHavenIndustries.Tests;
+
+public class WorkOrderBoardSearchFilterTests
+{
+    private static ApplicationDbContext CreateContext()
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+        return new ApplicationDbContext(options);
+    }
+
+    [Theory]
+    [InlineData("BK5", 1)]
+    [InlineData("10000000001", 1)]
+    [InlineData("HVAC Tech", 1)]
+    [InlineData("Acme HVAC", 1)]
+    [InlineData("sched", 1)]
+    [InlineData("Leak repair", 1)]
+    [InlineData("Reactive", 1)]
+    [InlineData("6/23", 1)]
+    public async Task Apply_MatchesExpectedField(string search, int expectedId)
+    {
+        await using var context = CreateContext();
+        await SeedSearchFixtures(context);
+
+        var ids = await WorkOrderBoardSearchFilter
+            .Apply(context.workOrders.AsQueryable(), search)
+            .Select(w => w.Id)
+            .ToListAsync();
+
+        Assert.Contains(expectedId, ids);
+    }
+
+    [Fact]
+    public void NormalizeSearch_IgnoresSingleCharacter()
+    {
+        Assert.Null(WorkOrderBoardSearchFilter.NormalizeSearch("a"));
+        Assert.Null(WorkOrderBoardSearchFilter.NormalizeSearch(" "));
+        Assert.Equal("ab", WorkOrderBoardSearchFilter.NormalizeSearch(" ab "));
+    }
+
+    [Fact]
+    public async Task Apply_LifecycleLabel_MatchesScheduled()
+    {
+        await using var context = CreateContext();
+        await SeedSearchFixtures(context);
+
+        var ids = await WorkOrderBoardSearchFilter
+            .Apply(context.workOrders.AsQueryable(), "scheduled")
+            .Select(w => w.Id)
+            .ToListAsync();
+
+        Assert.Single(ids);
+        Assert.Equal(1, ids[0]);
+    }
+
+    private static async Task SeedSearchFixtures(ApplicationDbContext context)
+    {
+        context.Vendors.Add(new Vendor
+        {
+            Id = 1,
+            CompanyName = "Acme HVAC",
+            ContactName = "HVAC Tech",
+            Phone = "555-0100"
+        });
+        context.Dispatches.Add(new Dispatch { Id = 10, VendorId = 1 });
+        context.workOrders.Add(new WorkOrder
+        {
+            Id = 1,
+            SiteCode = "BK5",
+            InternalWONumber = "10000000001",
+            WorkerOrderTitle = "Leak repair",
+            WorkOrderType = WorkOrderType.Reactive,
+            ScheduledDate = new DateTime(2026, 6, 23),
+            LifecycleStatus = LifecycleStatus.Scheduled,
+            PrimaryDispatchId = 10
+        });
+        await context.SaveChangesAsync();
+    }
+}
+
+public class WorkOrderBoardSearchCountsTests
+{
+    private static ApplicationDbContext CreateContext()
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+        return new ApplicationDbContext(options);
+    }
+
+    [Fact]
+    public async Task GetBoardRows_SearchReducesScheduledAndKeepsTotal()
+    {
+        await using var context = CreateContext();
+        var weekStart = new DateOnly(2026, 6, 22);
+
+        context.workOrders.AddRange(
+            new WorkOrder
+            {
+                Id = 1,
+                SiteCode = "BK5",
+                ScheduledDate = new DateTime(2026, 6, 23),
+                LifecycleStatus = LifecycleStatus.Scheduled
+            },
+            new WorkOrder
+            {
+                Id = 2,
+                SiteCode = "BK6",
+                ScheduledDate = new DateTime(2026, 6, 24),
+                LifecycleStatus = LifecycleStatus.Scheduled
+            },
+            new WorkOrder
+            {
+                Id = 3,
+                SiteCode = "BK5",
+                ScheduledDate = null,
+                LifecycleStatus = LifecycleStatus.Incomplete
+            });
+
+        await context.SaveChangesAsync();
+
+        var service = new WorkOrderBoardDataService(context);
+        var result = await service.GetBoardRowsAsync(new SeaHaven.DataServices.Interfaces.WorkOrderBoardQuery(
+            weekStart,
+            weekStart.AddDays(4),
+            null,
+            false,
+            null,
+            "BK5",
+            null));
+
+        Assert.Equal(2, result.ScheduledTotalBeforeSearch);
+        Assert.Single(result.ScheduledRows);
+        Assert.Equal("BK5", result.ScheduledRows[0].SiteCode);
+        Assert.Single(result.UnscheduledRows);
+        Assert.Equal("BK5", result.UnscheduledRows[0].SiteCode);
+    }
+}
+
+public class WorkOrderSearchDateRangeResolverTests
+{
+    [Fact]
+    public void Resolve_ThisWeek_UsesIsoMonday()
+    {
+        var reference = new DateOnly(2026, 6, 24);
+        var range = SeaHaven.Services.Helpers.WorkOrderSearchDateRangeResolver.Resolve(
+            SeaHaven.Services.Helpers.WorkOrderAdvancedSearchDatePreset.ThisWeek,
+            null,
+            null,
+            reference);
+
+        Assert.Equal(new DateOnly(2026, 6, 22), range.From);
+        Assert.Equal(new DateOnly(2026, 6, 26), range.To);
+    }
+
+    [Fact]
+    public void Resolve_Custom_RequiresDates()
+    {
+        var ex = Assert.Throws<ArgumentException>(() =>
+            SeaHaven.Services.Helpers.WorkOrderSearchDateRangeResolver.Resolve(
+                SeaHaven.Services.Helpers.WorkOrderAdvancedSearchDatePreset.Custom,
+                null,
+                null));
+
+        Assert.Contains("dateFrom", ex.Message);
+    }
+}
+
+public class WorkOrderAdvancedSearchServiceTests
+{
+    private static ApplicationDbContext CreateContext()
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+        return new ApplicationDbContext(options);
+    }
+
+    [Fact]
+    public async Task SearchAsync_FiltersBySiteAndPaginates()
+    {
+        await using var context = CreateContext();
+        var weekStart = new DateOnly(2026, 6, 22);
+
+        context.workOrders.AddRange(
+            new WorkOrder
+            {
+                Id = 1,
+                SiteCode = "BK5",
+                ScheduledDate = new DateTime(2026, 6, 23),
+                LifecycleStatus = LifecycleStatus.Scheduled,
+                InternalWONumber = "10000000001"
+            },
+            new WorkOrder
+            {
+                Id = 2,
+                SiteCode = "BK6",
+                ScheduledDate = new DateTime(2026, 6, 24),
+                LifecycleStatus = LifecycleStatus.Scheduled,
+                InternalWONumber = "10000000002"
+            });
+
+        await context.SaveChangesAsync();
+
+        var dataService = new WorkOrderAdvancedSearchDataService(context);
+        var service = new SeaHaven.Services.Implementation.WorkOrderAdvancedSearchService(dataService);
+
+        var result = await service.SearchAsync(new SeaHaven.Services.DTOs.WorkOrderAdvancedSearchQueryDto
+        {
+            DatePreset = SeaHaven.Services.Helpers.WorkOrderAdvancedSearchDatePreset.Custom,
+            DateFrom = weekStart,
+            DateTo = weekStart.AddDays(6),
+            Sites = new List<string> { "BK5" },
+            Page = 0,
+            PageSize = 50
+        }, null);
+
+        Assert.Equal(1, result.TotalCount);
+        Assert.Single(result.Items);
+        Assert.Equal("BK5", result.Items.First().SiteCode);
+    }
+
+    [Fact]
+    public async Task SearchAsync_ClampsPageSizeToMax()
+    {
+        await using var context = CreateContext();
+        var dataService = new WorkOrderAdvancedSearchDataService(context);
+        var service = new SeaHaven.Services.Implementation.WorkOrderAdvancedSearchService(dataService);
+
+        var result = await service.SearchAsync(new SeaHaven.Services.DTOs.WorkOrderAdvancedSearchQueryDto
+        {
+            DatePreset = SeaHaven.Services.Helpers.WorkOrderAdvancedSearchDatePreset.ThisWeek,
+            PageSize = 500
+        }, null);
+
+        Assert.Equal(100, result.PageSize);
+    }
+
+    [Fact]
+    public async Task SearchAsync_PageZero_ReturnsFirstPage()
+    {
+        await using var context = CreateContext();
+        var weekStart = new DateOnly(2026, 6, 22);
+
+        context.workOrders.AddRange(
+            new WorkOrder
+            {
+                Id = 1,
+                SiteCode = "BK5",
+                ScheduledDate = new DateTime(2026, 6, 23),
+                LifecycleStatus = LifecycleStatus.Scheduled,
+                InternalWONumber = "10000000001"
+            },
+            new WorkOrder
+            {
+                Id = 2,
+                SiteCode = "BK6",
+                ScheduledDate = new DateTime(2026, 6, 24),
+                LifecycleStatus = LifecycleStatus.Scheduled,
+                InternalWONumber = "10000000002"
+            });
+
+        await context.SaveChangesAsync();
+
+        var dataService = new WorkOrderAdvancedSearchDataService(context);
+        var service = new SeaHaven.Services.Implementation.WorkOrderAdvancedSearchService(dataService);
+
+        var result = await service.SearchAsync(new SeaHaven.Services.DTOs.WorkOrderAdvancedSearchQueryDto
+        {
+            DatePreset = SeaHaven.Services.Helpers.WorkOrderAdvancedSearchDatePreset.Custom,
+            DateFrom = weekStart,
+            DateTo = weekStart.AddDays(4),
+            Page = 0,
+            PageSize = 1
+        }, null);
+
+        Assert.Equal(2, result.TotalCount);
+        Assert.Single(result.Items);
+        Assert.Equal(0, result.Page);
+    }
+
+    [Fact]
+    public async Task SearchAsync_OverdueTypeSentinel_FiltersPastDueOnly()
+    {
+        await using var context = CreateContext();
+        var today = DateTime.UtcNow.Date;
+
+        context.workOrders.AddRange(
+            new WorkOrder
+            {
+                Id = 1,
+                WorkOrderType = WorkOrderType.PM,
+                ScheduledDate = today.AddDays(-3),
+                LifecycleStatus = LifecycleStatus.Scheduled,
+                InternalWONumber = "10000000001"
+            },
+            new WorkOrder
+            {
+                Id = 2,
+                WorkOrderType = WorkOrderType.Other,
+                ScheduledDate = today.AddDays(3),
+                LifecycleStatus = LifecycleStatus.Scheduled,
+                InternalWONumber = "10000000002"
+            });
+
+        await context.SaveChangesAsync();
+
+        var dataService = new WorkOrderAdvancedSearchDataService(context);
+        var service = new SeaHaven.Services.Implementation.WorkOrderAdvancedSearchService(dataService);
+
+        var result = await service.SearchAsync(new SeaHaven.Services.DTOs.WorkOrderAdvancedSearchQueryDto
+        {
+            DatePreset = SeaHaven.Services.Helpers.WorkOrderAdvancedSearchDatePreset.Custom,
+            DateFrom = DateOnly.FromDateTime(today.AddMonths(-1)),
+            DateTo = DateOnly.FromDateTime(today.AddMonths(1)),
+            Types = new List<WorkOrderType> { WorkOrderType.Other }
+        }, null);
+
+        Assert.Equal(1, result.TotalCount);
+        Assert.Equal(1, result.Items.First().Id);
+        Assert.True(result.Items.First().IsPastDue);
+    }
+
+    [Fact]
+    public async Task SearchAsync_IncludesUnscheduledRows()
+    {
+        await using var context = CreateContext();
+        var weekStart = new DateOnly(2026, 6, 22);
+
+        context.workOrders.AddRange(
+            new WorkOrder
+            {
+                Id = 1,
+                ScheduledDate = new DateTime(2026, 6, 23),
+                LifecycleStatus = LifecycleStatus.Scheduled,
+                InternalWONumber = "10000000001"
+            },
+            new WorkOrder
+            {
+                Id = 2,
+                ScheduledDate = null,
+                LifecycleStatus = LifecycleStatus.Incomplete,
+                InternalWONumber = "10000000002"
+            });
+
+        await context.SaveChangesAsync();
+
+        var dataService = new WorkOrderAdvancedSearchDataService(context);
+        var service = new SeaHaven.Services.Implementation.WorkOrderAdvancedSearchService(dataService);
+
+        var result = await service.SearchAsync(new SeaHaven.Services.DTOs.WorkOrderAdvancedSearchQueryDto
+        {
+            DatePreset = SeaHaven.Services.Helpers.WorkOrderAdvancedSearchDatePreset.Custom,
+            DateFrom = weekStart,
+            DateTo = weekStart.AddDays(4)
+        }, null);
+
+        Assert.Equal(2, result.TotalCount);
+        Assert.Contains(result.Items, i => i.Id == 2);
+    }
+
+    [Fact]
+    public async Task SearchAsync_InvalidSortBy_Throws()
+    {
+        await using var context = CreateContext();
+        var dataService = new WorkOrderAdvancedSearchDataService(context);
+        var service = new SeaHaven.Services.Implementation.WorkOrderAdvancedSearchService(dataService);
+
+        var ex = await Assert.ThrowsAsync<ArgumentException>(() => service.SearchAsync(
+            new SeaHaven.Services.DTOs.WorkOrderAdvancedSearchQueryDto
+            {
+                DatePreset = SeaHaven.Services.Helpers.WorkOrderAdvancedSearchDatePreset.ThisWeek,
+                SortBy = "invalid"
+            }, null));
+
+        Assert.Contains("sortBy", ex.Message);
+    }
+}
diff --git a/SeaHavenIndustries.Tests/WorkOrderBoardServiceTests.cs b/SeaHavenIndustries.Tests/WorkOrderBoardServiceTests.cs
new file mode 100644
index 0000000..8b1b867
--- /dev/null
+++ b/SeaHavenIndustries.Tests/WorkOrderBoardServiceTests.cs
@@ -0,0 +1,210 @@
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+using Microsoft.EntityFrameworkCore;
+using SeaHaven.DataServices.Implementation;
+using SeaHaven.DataServices.Interfaces;
+using SeaHaven.Services.DTOs;
+using SeaHaven.Services.Implementation;
+
+namespace SeaHavenIndustries.Tests;
+
+public class WorkOrderBoardDataServiceTests
+{
+    private static ApplicationDbContext CreateContext()
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+        return new ApplicationDbContext(options);
+    }
+
+    [Fact]
+    public async Task GetBoardRows_ReturnsScheduledInWeekAndUnscheduled()
+    {
+        await using var context = CreateContext();
+        var weekStart = new DateOnly(2026, 6, 22);
+
+        context.Vendors.Add(new Vendor { Id = 1, CompanyName = "Acme HVAC", ContactName = "Tech", Phone = "555-0100" });
+        context.Dispatches.Add(new Dispatch
+        {
+            Id = 10,
+            VendorId = 1,
+            ScheduledDate = new DateTime(2026, 6, 24, 8, 0, 0)
+        });
+
+        context.workOrders.AddRange(
+            new WorkOrder
+            {
+                Id = 1,
+                InternalWONumber = "10000000001",
+                ScheduledDate = new DateTime(2026, 6, 23),
+                LifecycleStatus = LifecycleStatus.Scheduled,
+                PrimaryDispatchId = 10,
+                SiteCode = "BK5"
+            },
+            new WorkOrder
+            {
+                Id = 2,
+                InternalWONumber = "10000000002",
+                ScheduledDate = null,
+                LifecycleStatus = LifecycleStatus.Incomplete,
+                SiteCode = "BK6"
+            },
+            new WorkOrder
+            {
+                Id = 3,
+                InternalWONumber = "10000000003",
+                ScheduledDate = new DateTime(2026, 7, 1),
+                LifecycleStatus = LifecycleStatus.Scheduled
+            });
+
+        await context.SaveChangesAsync();
+
+        var service = new WorkOrderBoardDataService(context);
+        var result = await service.GetBoardRowsAsync(new WorkOrderBoardQuery(
+            weekStart,
+            weekStart.AddDays(4),
+            null,
+            false,
+            null,
+            null,
+            null));
+
+        Assert.Single(result.ScheduledRows);
+        Assert.Equal(1, result.ScheduledRows[0].Id);
+        Assert.Equal("Acme HVAC", result.ScheduledRows[0].VendorName);
+        Assert.Single(result.UnscheduledRows);
+        Assert.Equal(2, result.UnscheduledRows[0].Id);
+        Assert.Equal(1, result.ScheduledTotalBeforeSearch);
+    }
+
+    [Fact]
+    public async Task GetBoardRows_FiltersByDispatcher()
+    {
+        await using var context = CreateContext();
+        var weekStart = new DateOnly(2026, 6, 22);
+
+        context.workOrders.AddRange(
+            new WorkOrder
+            {
+                Id = 1,
+                AssignTo = "user-a",
+                ScheduledDate = new DateTime(2026, 6, 23),
+                LifecycleStatus = LifecycleStatus.Scheduled
+            },
+            new WorkOrder
+            {
+                Id = 2,
+                AssignTo = "user-b",
+                ScheduledDate = new DateTime(2026, 6, 24),
+                LifecycleStatus = LifecycleStatus.Scheduled
+            });
+
+        await context.SaveChangesAsync();
+
+        var service = new WorkOrderBoardDataService(context);
+        var result = await service.GetBoardRowsAsync(new WorkOrderBoardQuery(
+            weekStart,
+            weekStart.AddDays(4),
+            new[] { "user-a" },
+            false,
+            null,
+            null,
+            null));
+
+        Assert.Single(result.ScheduledRows);
+        Assert.Equal("user-a", result.ScheduledRows[0].AssignTo);
+    }
+
+    [Fact]
+    public async Task GetBoardRows_MyWorkOrders_FiltersCurrentUser()
+    {
+        await using var context = CreateContext();
+        var weekStart = new DateOnly(2026, 6, 22);
+
+        context.workOrders.AddRange(
+            new WorkOrder
+            {
+                Id = 1,
+                AssignTo = "me",
+                ScheduledDate = new DateTime(2026, 6, 23),
+                LifecycleStatus = LifecycleStatus.Scheduled
+            },
+            new WorkOrder
+            {
+                Id = 2,
+                AssignTo = "other",
+                ScheduledDate = new DateTime(2026, 6, 23),
+                LifecycleStatus = LifecycleStatus.Scheduled
+            });
+
+        await context.SaveChangesAsync();
+
+        var service = new WorkOrderBoardDataService(context);
+        var result = await service.GetBoardRowsAsync(new WorkOrderBoardQuery(
+            weekStart,
+            weekStart.AddDays(4),
+            null,
+            true,
+            null,
+            null,
+            "me"));
+
+        Assert.Single(result.ScheduledRows);
+        Assert.Equal(1, result.ScheduledRows[0].Id);
+    }
+}
+
+public class WorkOrderBoardServiceTests
+{
+    private static ApplicationDbContext CreateContext()
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+        return new ApplicationDbContext(options);
+    }
+
+    [Fact]
+    public async Task GetBoardAsync_ComputesCountsAndPastDue()
+    {
+        await using var context = CreateContext();
+        var weekStart = new DateOnly(2026, 6, 22);
+
+        context.workOrders.Add(new WorkOrder
+        {
+            Id = 1,
+            InternalWONumber = "10000000001",
+            ScheduledDate = new DateTime(2026, 6, 24, 12, 0, 0, DateTimeKind.Utc),
+            LifecycleStatus = LifecycleStatus.Scheduled
+        });
+
+        await context.SaveChangesAsync();
+
+        var dataService = new WorkOrderBoardDataService(context);
+        var boardService = new WorkOrderBoardService(dataService);
+
+        var response = await boardService.GetBoardAsync(new WorkOrderBoardQueryDto
+        {
+            WeekStart = weekStart
+        }, null);
+
+        Assert.Equal(1, response.Counts.Total);
+        Assert.Single(response.Scheduled);
+        Assert.True(response.Scheduled[0].IsPastDue);
+        Assert.Equal("wednesday", response.Scheduled[0].DayGroup);
+    }
+
+    [Fact]
+    public async Task GetBoardAsync_InvalidWeekWindow_Throws()
+    {
+        await using var context = CreateContext();
+        var boardService = new WorkOrderBoardService(new WorkOrderBoardDataService(context));
+
+        await Assert.ThrowsAsync<ArgumentException>(() => boardService.GetBoardAsync(new WorkOrderBoardQueryDto
+        {
+            WeekStart = new DateOnly(2026, 6, 22),
+            WeekEnd = new DateOnly(2026, 6, 15)
+        }, null));
+    }
+}
diff --git a/SeaHavenIndustries.Tests/WorkOrderBoardUpdateServiceTests.cs b/SeaHavenIndustries.Tests/WorkOrderBoardUpdateServiceTests.cs
new file mode 100644
index 0000000..ecaba65
--- /dev/null
+++ b/SeaHavenIndustries.Tests/WorkOrderBoardUpdateServiceTests.cs
@@ -0,0 +1,506 @@
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+using Microsoft.EntityFrameworkCore;
+using SeaHaven.DataServices.Implementation;
+using SeaHaven.Services.DTOs;
+using SeaHaven.Services.Exceptions;
+using SeaHaven.Services.Helpers;
+using SeaHaven.Services.Implementation;
+
+namespace SeaHavenIndustries.Tests;
+
+public class WorkOrderBoardUpdateServiceTests
+{
+    private static (ApplicationDbContext Context, WorkOrderBoardUpdateService Service) CreateSut()
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+        var context = new ApplicationDbContext(options);
+        var boardData = new WorkOrderBoardDataService(context);
+        var fieldLocks = new WorkOrderFieldLockService(context);
+        var audit = new WorkOrderAuditService(context, fieldLocks);
+        var service = new WorkOrderBoardUpdateService(context, boardData, audit);
+        return (context, service);
+    }
+
+    private static string ToVersion(WorkOrder workOrder)
+        => Convert.ToBase64String(workOrder.RowVersion ?? new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 });
+
+    private static string ToVersion(Dispatch dispatch)
+        => Convert.ToBase64String(dispatch.RowVersion ?? new byte[] { 1, 0, 0, 0, 0, 0, 0, 2 });
+
+    [Fact]
+    public async Task PatchField_AutoSchedulesIncompleteToScheduled()
+    {
+        var (context, service) = CreateSut();
+        var wo = new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Incomplete,
+            AssignTo = "user-a",
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        };
+        context.workOrders.Add(wo);
+        await context.SaveChangesAsync();
+
+        var result = await service.PatchFieldAsync(1, new WorkOrderBoardPatchRequestDto
+        {
+            Field = WorkOrderBoardFieldNames.ScheduledDate,
+            Value = "2026-06-25",
+            WorkOrderVersion = ToVersion(wo)
+        }, "actor-1");
+
+        Assert.Equal(LifecycleStatus.Scheduled, result.LifecycleStatus);
+        Assert.Equal(2, await context.WorkOrderAuditLogs.CountAsync());
+    }
+
+    [Fact]
+    public async Task PatchField_IncrementsRescheduleCount()
+    {
+        var (context, service) = CreateSut();
+        var wo = new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Scheduled,
+            ScheduledDate = new DateTime(2026, 6, 20),
+            RescheduleCount = 1,
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        };
+        context.workOrders.Add(wo);
+        await context.SaveChangesAsync();
+
+        var result = await service.PatchFieldAsync(1, new WorkOrderBoardPatchRequestDto
+        {
+            Field = WorkOrderBoardFieldNames.ScheduledDate,
+            Value = "2026-06-25",
+            WorkOrderVersion = ToVersion(wo)
+        }, "actor-1");
+
+        Assert.Equal(2, result.RescheduleCount);
+    }
+
+    [Fact]
+    public async Task PatchField_BlocksStatusChangeWhenPastDue()
+    {
+        var (context, service) = CreateSut();
+        var wo = new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Scheduled,
+            ScheduledDate = DateTime.UtcNow.Date.AddDays(-3),
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        };
+        context.workOrders.Add(wo);
+        await context.SaveChangesAsync();
+
+        var ex = await Assert.ThrowsAsync<WorkOrderBoardValidationException>(() =>
+            service.PatchFieldAsync(1, new WorkOrderBoardPatchRequestDto
+            {
+                Field = WorkOrderBoardFieldNames.LifecycleStatus,
+                Value = "Complete",
+                WorkOrderVersion = ToVersion(wo)
+            }, "actor-1"));
+
+        Assert.Equal("PastDueStatusBlocked", ex.Code);
+    }
+
+    [Fact]
+    public async Task PatchField_RejectsOverdueAsWorkOrderType()
+    {
+        var (context, service) = CreateSut();
+        var wo = new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Scheduled,
+            WorkOrderType = WorkOrderType.Reactive,
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        };
+        context.workOrders.Add(wo);
+        await context.SaveChangesAsync();
+
+        var ex = await Assert.ThrowsAsync<WorkOrderBoardValidationException>(() =>
+            service.PatchFieldAsync(1, new WorkOrderBoardPatchRequestDto
+            {
+                Field = WorkOrderBoardFieldNames.WorkOrderType,
+                Value = "Overdue",
+                WorkOrderVersion = ToVersion(wo)
+            }, "actor-1"));
+
+        Assert.Equal("InvalidValue", ex.Code);
+        Assert.Contains("isPastDue", ex.Message, StringComparison.Ordinal);
+        Assert.Contains("scheduledDate", ex.Message, StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public async Task PatchField_BlocksEditWhenCanceled()
+    {
+        var (context, service) = CreateSut();
+        var wo = new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Canceled,
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        };
+        context.workOrders.Add(wo);
+        await context.SaveChangesAsync();
+
+        var ex = await Assert.ThrowsAsync<WorkOrderBoardValidationException>(() =>
+            service.PatchFieldAsync(1, new WorkOrderBoardPatchRequestDto
+            {
+                Field = WorkOrderBoardFieldNames.SiteCode,
+                Value = "BK5",
+                WorkOrderVersion = ToVersion(wo)
+            }, "actor-1"));
+
+        Assert.Equal("CanceledReadOnly", ex.Code);
+    }
+
+    [Fact]
+    public async Task PatchField_VendorCreatesPrimaryDispatch()
+    {
+        var (context, service) = CreateSut();
+        context.Vendors.Add(new Vendor { Id = 5, CompanyName = "Vendor Co" });
+        var wo = new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Incomplete,
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        };
+        context.workOrders.Add(wo);
+        await context.SaveChangesAsync();
+
+        var result = await service.PatchFieldAsync(1, new WorkOrderBoardPatchRequestDto
+        {
+            Field = WorkOrderBoardFieldNames.VendorId,
+            Value = "5",
+            WorkOrderVersion = ToVersion(wo)
+        }, "actor-1");
+
+        Assert.NotNull(result.PrimaryDispatchId);
+        Assert.Equal(5, result.VendorId);
+        Assert.Equal(1, await context.Dispatches.CountAsync());
+    }
+
+    [Fact]
+    public async Task PatchField_CreatesFieldLockAndAuditPerField()
+    {
+        var (context, service) = CreateSut();
+        var wo = new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Scheduled,
+            SiteCode = "OLD",
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        };
+        context.workOrders.Add(wo);
+        await context.SaveChangesAsync();
+
+        await service.PatchFieldAsync(1, new WorkOrderBoardPatchRequestDto
+        {
+            Field = WorkOrderBoardFieldNames.SiteCode,
+            Value = "BK5",
+            WorkOrderVersion = ToVersion(wo)
+        }, "actor-1");
+
+        Assert.Single(await context.WorkOrderAuditLogs.Where(a => a.Action == AuditActionType.FieldChanged.ToString()).ToListAsync());
+        Assert.True(await context.WorkOrderFieldLocks.AnyAsync(l => l.FieldName == "SiteCode"));
+    }
+
+    [Fact]
+    public async Task PatchField_NormalizesWoNumber()
+    {
+        var (context, service) = CreateSut();
+        var wo = new WorkOrder
+        {
+            Id = 1,
+            InternalWONumber = "00000009999",
+            LifecycleStatus = LifecycleStatus.Incomplete,
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        };
+        context.workOrders.Add(wo);
+        await context.SaveChangesAsync();
+
+        var result = await service.PatchFieldAsync(1, new WorkOrderBoardPatchRequestDto
+        {
+            Field = WorkOrderBoardFieldNames.WoNumber,
+            Value = "12345",
+            WorkOrderVersion = ToVersion(wo)
+        }, "actor-1");
+
+        Assert.Equal("00000012345", result.WoNumber);
+    }
+
+    [Fact]
+    public async Task PatchField_RejectsDuplicateWoNumber()
+    {
+        var (context, service) = CreateSut();
+        context.workOrders.AddRange(
+            new WorkOrder { Id = 1, InternalWONumber = "00000011111", RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 } },
+            new WorkOrder { Id = 2, InternalWONumber = "00000022222", RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 2 } });
+        await context.SaveChangesAsync();
+
+        var wo = await context.workOrders.FindAsync(1);
+        var ex = await Assert.ThrowsAsync<WorkOrderBoardValidationException>(() =>
+            service.PatchFieldAsync(1, new WorkOrderBoardPatchRequestDto
+            {
+                Field = WorkOrderBoardFieldNames.WoNumber,
+                Value = "22222",
+                WorkOrderVersion = ToVersion(wo!)
+            }, "actor-1"));
+
+        Assert.Equal("DuplicateWoNumber", ex.Code);
+    }
+
+    [Fact]
+    public async Task PatchField_UpdatesPmTrade()
+    {
+        var (context, service) = CreateSut();
+        var wo = new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Incomplete,
+            Trade = "HVAC",
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        };
+        context.workOrders.Add(wo);
+        await context.SaveChangesAsync();
+
+        var result = await service.PatchFieldAsync(1, new WorkOrderBoardPatchRequestDto
+        {
+            Field = WorkOrderBoardFieldNames.Pm,
+            Value = "Plumbing",
+            WorkOrderVersion = ToVersion(wo)
+        }, "actor-1");
+
+        Assert.Equal("Plumbing", result.Pm);
+        Assert.Equal("Plumbing", (await context.workOrders.FindAsync(1))!.Trade);
+    }
+
+    [Fact]
+    public async Task PatchField_UpdatesServiceNotesAndReturnsOnBoardRow()
+    {
+        var (context, service) = CreateSut();
+        var wo = new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Incomplete,
+            Trade = "Backflow Preventers",
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        };
+        context.workOrders.Add(wo);
+        await context.SaveChangesAsync();
+
+        var result = await service.PatchFieldAsync(1, new WorkOrderBoardPatchRequestDto
+        {
+            Field = WorkOrderBoardFieldNames.ServiceNotes,
+            Value = "service notes",
+            WorkOrderVersion = ToVersion(wo)
+        }, "actor-1");
+
+        Assert.Equal("service notes", result.ServiceNotes);
+        Assert.Equal("service notes", (await context.workOrders.FindAsync(1))!.ServiceNotes);
+    }
+
+    [Fact]
+    public async Task PatchField_UpdatesExtraServices_WhenPrimaryExists()
+    {
+        var (context, service) = CreateSut();
+        var wo = new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Incomplete,
+            Trade = "Backflow Preventers",
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        };
+        context.workOrders.Add(wo);
+        await context.SaveChangesAsync();
+
+        var result = await service.PatchFieldAsync(1, new WorkOrderBoardPatchRequestDto
+        {
+            Field = WorkOrderBoardFieldNames.ExtraServices,
+            Value = "[\"Filter change\",\"Coil clean\"]",
+            WorkOrderVersion = ToVersion(wo)
+        }, "actor-1");
+
+        Assert.Equal(new[] { "Filter change", "Coil clean" }, result.ExtraServices);
+        Assert.Contains("Filter change", (await context.workOrders.FindAsync(1))!.ExtraServices);
+    }
+
+    [Fact]
+    public async Task PatchField_ExtraServicesWithoutPrimary_Throws()
+    {
+        var (context, service) = CreateSut();
+        var wo = new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Incomplete,
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        };
+        context.workOrders.Add(wo);
+        await context.SaveChangesAsync();
+
+        var ex = await Assert.ThrowsAsync<WorkOrderBoardValidationException>(() =>
+            service.PatchFieldAsync(1, new WorkOrderBoardPatchRequestDto
+            {
+                Field = WorkOrderBoardFieldNames.ExtraServices,
+                Value = "[\"Filter change\"]",
+                WorkOrderVersion = ToVersion(wo)
+            }, "actor-1"));
+
+        Assert.Equal("InvalidValue", ex.Code);
+    }
+
+    [Fact]
+    public async Task PatchField_SetsFlagColor_CanonicalUppercase()
+    {
+        var (context, service) = CreateSut();
+        var wo = new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Incomplete,
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        };
+        context.workOrders.Add(wo);
+        await context.SaveChangesAsync();
+
+        var result = await service.PatchFieldAsync(1, new WorkOrderBoardPatchRequestDto
+        {
+            Field = WorkOrderBoardFieldNames.FlagColor,
+            Value = "#ef4444",
+            WorkOrderVersion = ToVersion(wo)
+        }, "actor-1");
+
+        Assert.Equal("#EF4444", result.FlagColor);
+        Assert.Equal("#EF4444", (await context.workOrders.FindAsync(1))!.FlagColor);
+    }
+
+    [Fact]
+    public async Task PatchField_ClearsFlagColor_WithNullOrEmpty()
+    {
+        var (context, service) = CreateSut();
+        var wo = new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Incomplete,
+            FlagColor = "#EF4444",
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        };
+        context.workOrders.Add(wo);
+        await context.SaveChangesAsync();
+
+        var cleared = await service.PatchFieldAsync(1, new WorkOrderBoardPatchRequestDto
+        {
+            Field = WorkOrderBoardFieldNames.FlagColor,
+            Value = "",
+            WorkOrderVersion = ToVersion(wo)
+        }, "actor-1");
+
+        Assert.Null(cleared.FlagColor);
+        Assert.Null((await context.workOrders.FindAsync(1))!.FlagColor);
+    }
+
+    [Fact]
+    public async Task PatchField_ClearsFlagColor_WithNullValue()
+    {
+        var (context, service) = CreateSut();
+        var wo = new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Incomplete,
+            FlagColor = "#3B82F6",
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        };
+        context.workOrders.Add(wo);
+        await context.SaveChangesAsync();
+
+        var cleared = await service.PatchFieldAsync(1, new WorkOrderBoardPatchRequestDto
+        {
+            Field = WorkOrderBoardFieldNames.FlagColor,
+            Value = null,
+            WorkOrderVersion = ToVersion(wo)
+        }, "actor-1");
+
+        Assert.Null(cleared.FlagColor);
+        Assert.Null((await context.workOrders.FindAsync(1))!.FlagColor);
+    }
+
+    [Fact]
+    public async Task PatchField_FlagColorOutsidePalette_Throws()
+    {
+        var (context, service) = CreateSut();
+        var wo = new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Incomplete,
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        };
+        context.workOrders.Add(wo);
+        await context.SaveChangesAsync();
+
+        var ex = await Assert.ThrowsAsync<WorkOrderBoardValidationException>(() =>
+            service.PatchFieldAsync(1, new WorkOrderBoardPatchRequestDto
+            {
+                Field = WorkOrderBoardFieldNames.FlagColor,
+                Value = "#000000",
+                WorkOrderVersion = ToVersion(wo)
+            }, "actor-1"));
+
+        Assert.Equal("InvalidValue", ex.Code);
+    }
+
+    [Fact]
+    public async Task PatchField_FlagColorMalformed_Throws()
+    {
+        var (context, service) = CreateSut();
+        var wo = new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Incomplete,
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        };
+        context.workOrders.Add(wo);
+        await context.SaveChangesAsync();
+
+        var ex = await Assert.ThrowsAsync<WorkOrderBoardValidationException>(() =>
+            service.PatchFieldAsync(1, new WorkOrderBoardPatchRequestDto
+            {
+                Field = WorkOrderBoardFieldNames.FlagColor,
+                Value = "not-a-color",
+                WorkOrderVersion = ToVersion(wo)
+            }, "actor-1"));
+
+        Assert.Equal("InvalidValue", ex.Code);
+    }
+
+    [Fact]
+    public async Task PatchField_FlagColor_DoesNotRequireDispatchVersion()
+    {
+        var (context, service) = CreateSut();
+        var wo = new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Incomplete,
+            PrimaryDispatchId = 10,
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        };
+        context.Dispatches.Add(new Dispatch
+        {
+            Id = 10,
+            WorkOrderId = 1,
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 2 }
+        });
+        context.workOrders.Add(wo);
+        await context.SaveChangesAsync();
+
+        var result = await service.PatchFieldAsync(1, new WorkOrderBoardPatchRequestDto
+        {
+            Field = WorkOrderBoardFieldNames.FlagColor,
+            Value = "#8B5CF6",
+            WorkOrderVersion = ToVersion(wo)
+            // no DispatchVersion
+        }, "actor-1");
+
+        Assert.Equal("#8B5CF6", result.FlagColor);
+    }
+}
diff --git a/SeaHavenIndustries.Tests/WorkOrderDerivedFieldsTests.cs b/SeaHavenIndustries.Tests/WorkOrderDerivedFieldsTests.cs
new file mode 100644
index 0000000..0d1f61c
--- /dev/null
+++ b/SeaHavenIndustries.Tests/WorkOrderDerivedFieldsTests.cs
@@ -0,0 +1,75 @@
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+using SeaHaven.Services.Helpers;
+
+namespace SeaHavenIndustries.Tests;
+
+public class WorkOrderDerivedFieldsTests
+{
+    [Fact]
+    public void IsPastDue_WhenScheduledBeforeTodayAndNotTerminal_ReturnsTrue()
+    {
+        var wo = new WorkOrder
+        {
+            ScheduledDate = DateTime.UtcNow.AddDays(-2),
+            LifecycleStatus = LifecycleStatus.Scheduled
+        };
+
+        Assert.True(WorkOrderDerivedFields.IsPastDue(wo, DateOnly.FromDateTime(DateTime.UtcNow)));
+    }
+
+    [Fact]
+    public void IsPastDue_WhenCompleted_ReturnsFalse()
+    {
+        var wo = new WorkOrder
+        {
+            ScheduledDate = DateTime.UtcNow.AddDays(-2),
+            LifecycleStatus = LifecycleStatus.Completed
+        };
+
+        Assert.False(WorkOrderDerivedFields.IsPastDue(wo, DateOnly.FromDateTime(DateTime.UtcNow)));
+    }
+
+    [Fact]
+    public void ApplyAutoSchedule_WhenDateAndAssignee_PromotesToScheduled()
+    {
+        var wo = new WorkOrder
+        {
+            LifecycleStatus = LifecycleStatus.Incomplete,
+            ScheduledDate = new DateTime(2026, 6, 25),
+            AssignTo = "dispatcher-1"
+        };
+
+        Assert.True(WorkOrderDerivedFields.ApplyAutoScheduleIfEligible(wo));
+        Assert.Equal(LifecycleStatus.Scheduled, wo.LifecycleStatus);
+    }
+
+    [Fact]
+    public void ApplyAutoSchedule_WeekOnly_DoesNotPromote()
+    {
+        var wo = new WorkOrder
+        {
+            LifecycleStatus = LifecycleStatus.Incomplete,
+            ScheduledDate = new DateTime(2026, 6, 25),
+            AssignTo = "dispatcher-1",
+            ScheduleWeekOnly = true,
+            TargetWeek = new DateOnly(2026, 6, 22)
+        };
+
+        Assert.False(WorkOrderDerivedFields.ApplyAutoScheduleIfEligible(wo));
+        Assert.Equal(LifecycleStatus.Incomplete, wo.LifecycleStatus);
+    }
+
+    [Fact]
+    public void SetInitialLifecycleStatus_NewWo_StartsIncompleteThenAutoSchedules()
+    {
+        var wo = new WorkOrder
+        {
+            ScheduledDate = new DateTime(2026, 6, 25),
+            AssignTo = "dispatcher-1"
+        };
+
+        WorkOrderDerivedFields.SetInitialLifecycleStatus(wo);
+        Assert.Equal(LifecycleStatus.Scheduled, wo.LifecycleStatus);
+    }
+}
diff --git a/SeaHavenIndustries.Tests/WorkOrderFieldLockServiceTests.cs b/SeaHavenIndustries.Tests/WorkOrderFieldLockServiceTests.cs
new file mode 100644
index 0000000..b598a4d
--- /dev/null
+++ b/SeaHavenIndustries.Tests/WorkOrderFieldLockServiceTests.cs
@@ -0,0 +1,53 @@
+using Data.SeaHavenIndustries;
+using Microsoft.EntityFrameworkCore;
+using SeaHaven.Services.Constants;
+using SeaHaven.Services.Implementation;
+
+namespace SeaHavenIndustries.Tests;
+
+public class WorkOrderFieldLockServiceTests
+{
+    private static ApplicationDbContext CreateContext()
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+        return new ApplicationDbContext(options);
+    }
+
+    [Fact]
+    public async Task LockFieldAsync_DuplicateCalls_EnqueuesSingleLock()
+    {
+        await using var context = CreateContext();
+        var locks = new WorkOrderFieldLockService(context);
+
+        await locks.LockFieldAsync(1, WorkOrderFieldNames.Description, "user-1");
+        await locks.LockFieldAsync(1, WorkOrderFieldNames.Description, "user-2");
+        await context.SaveChangesAsync();
+
+        var fieldLocks = await context.WorkOrderFieldLocks.ToListAsync();
+        Assert.Single(fieldLocks);
+        Assert.Equal(WorkOrderFieldNames.Description, fieldLocks[0].FieldName);
+    }
+
+    [Fact]
+    public async Task LockFieldAsync_WhenAlreadyPersisted_IsIdempotent()
+    {
+        await using var context = CreateContext();
+        context.WorkOrderFieldLocks.Add(new WorkOrderFieldLock
+        {
+            WorkOrderId = 2,
+            FieldName = WorkOrderFieldNames.AssignTo,
+            LockedAt = DateTime.UtcNow,
+            LockedByUserId = "user-1"
+        });
+        await context.SaveChangesAsync();
+
+        var locks = new WorkOrderFieldLockService(context);
+        await locks.LockFieldAsync(2, WorkOrderFieldNames.AssignTo, "user-2");
+        await context.SaveChangesAsync();
+
+        var fieldLocks = await context.WorkOrderFieldLocks.ToListAsync();
+        Assert.Single(fieldLocks);
+    }
+}
diff --git a/SeaHavenIndustries.Tests/WorkOrderNumberNormalizerTests.cs b/SeaHavenIndustries.Tests/WorkOrderNumberNormalizerTests.cs
new file mode 100644
index 0000000..dcc4755
--- /dev/null
+++ b/SeaHavenIndustries.Tests/WorkOrderNumberNormalizerTests.cs
@@ -0,0 +1,43 @@
+using SeaHaven.Services.Helpers;
+
+namespace SeaHavenIndustries.Tests;
+
+public class WorkOrderNumberNormalizerTests
+{
+    [Fact]
+    public void TryNormalize_PadsToElevenDigits()
+    {
+        var ok = WorkOrderNumberNormalizer.TryNormalize("12345", out var normalized, out var error);
+
+        Assert.True(ok);
+        Assert.Null(error);
+        Assert.Equal("00000012345", normalized);
+    }
+
+    [Fact]
+    public void TryNormalize_AcceptsElevenDigits()
+    {
+        var ok = WorkOrderNumberNormalizer.TryNormalize("10000000001", out var normalized, out _);
+
+        Assert.True(ok);
+        Assert.Equal("10000000001", normalized);
+    }
+
+    [Fact]
+    public void TryNormalize_RejectsEmpty()
+    {
+        var ok = WorkOrderNumberNormalizer.TryNormalize("", out _, out var error);
+
+        Assert.False(ok);
+        Assert.NotNull(error);
+    }
+
+    [Fact]
+    public void TryNormalize_RejectsTooLong()
+    {
+        var ok = WorkOrderNumberNormalizer.TryNormalize("123456789012", out _, out var error);
+
+        Assert.False(ok);
+        Assert.Contains("11", error);
+    }
+}
diff --git a/SeaHavenIndustries.Tests/WorkOrderPhase6Tests.cs b/SeaHavenIndustries.Tests/WorkOrderPhase6Tests.cs
new file mode 100644
index 0000000..6133102
--- /dev/null
+++ b/SeaHavenIndustries.Tests/WorkOrderPhase6Tests.cs
@@ -0,0 +1,656 @@
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+using Microsoft.EntityFrameworkCore;
+using SeaHaven.DataServices.Implementation;
+using SeaHaven.Services.DTOs;
+using SeaHaven.Services.Exceptions;
+using SeaHaven.Services.Helpers;
+using SeaHaven.Services.Implementation;
+
+namespace SeaHavenIndustries.Tests;
+
+public class WorkOrderDocStatusPatchTests
+{
+    private static (ApplicationDbContext Context, WorkOrderBoardUpdateService Service) CreateSut()
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+        var context = new ApplicationDbContext(options);
+        var boardData = new WorkOrderBoardDataService(context);
+        var fieldLocks = new WorkOrderFieldLockService(context);
+        var audit = new WorkOrderAuditService(context, fieldLocks);
+        var service = new WorkOrderBoardUpdateService(context, boardData, audit);
+        return (context, service);
+    }
+
+    private static string ToVersion(WorkOrder workOrder)
+        => Convert.ToBase64String(workOrder.RowVersion ?? new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 });
+
+    [Theory]
+    [InlineData("Yes", DocStatus.Yes)]
+    [InlineData("No", DocStatus.No)]
+    [InlineData("NotNeeded", DocStatus.NotNeeded)]
+    public async Task PatchField_DocStatus_SetsValue(string value, DocStatus expected)
+    {
+        var (context, service) = CreateSut();
+        var wo = new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Scheduled,
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        };
+        context.workOrders.Add(wo);
+        await context.SaveChangesAsync();
+
+        var result = await service.PatchFieldAsync(1, new WorkOrderBoardPatchRequestDto
+        {
+            Field = WorkOrderBoardFieldNames.DocStatus,
+            Value = value,
+            WorkOrderVersion = ToVersion(wo)
+        }, "actor-1");
+
+        Assert.Equal(expected, result.DocStatus);
+        var audit = await context.WorkOrderAuditLogs.SingleAsync();
+        Assert.Equal("DocStatus", audit.FieldName);
+    }
+
+    [Fact]
+    public async Task PatchField_DocStatus_ReadOnlyWorkOrder_Throws()
+    {
+        var (context, service) = CreateSut();
+        var wo = new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Canceled,
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        };
+        context.workOrders.Add(wo);
+        await context.SaveChangesAsync();
+
+        var ex = await Assert.ThrowsAsync<WorkOrderBoardValidationException>(() =>
+            service.PatchFieldAsync(1, new WorkOrderBoardPatchRequestDto
+            {
+                Field = WorkOrderBoardFieldNames.DocStatus,
+                Value = "Yes",
+                WorkOrderVersion = ToVersion(wo)
+            }, "actor-1"));
+
+        Assert.Equal("CanceledReadOnly", ex.Code);
+    }
+}
+
+public class WorkOrderDetailServiceTests
+{
+    private static (ApplicationDbContext Context, WorkOrderDetailService Service) CreateSut()
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+        var context = new ApplicationDbContext(options);
+        var boardData = new WorkOrderBoardDataService(context);
+        var boardService = new WorkOrderBoardService(boardData);
+        var detailData = new WorkOrderDetailDataService(context);
+        var templateData = new CompletionDocTemplateDataService(context);
+        var userData = new UserDataService(context);
+        var service = new WorkOrderDetailService(boardService, detailData, templateData, userData);
+        return (context, service);
+    }
+
+    [Fact]
+    public async Task GetDetail_ReturnsDerivedFieldsAndFeAuditMapping()
+    {
+        var (context, service) = CreateSut();
+        var wo = new WorkOrder
+        {
+            Id = 1,
+            InternalWONumber = "00000000001",
+            LifecycleStatus = LifecycleStatus.Scheduled,
+            ScheduledDate = DateTime.UtcNow.AddDays(-2),
+            Trade = "HVAC PM",
+            WorkOrderType = WorkOrderType.PM,
+            DocStatus = DocStatus.No,
+            Description = "Leak",
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        };
+        context.workOrders.Add(wo);
+        context.CompletionDocTemplates.Add(new CompletionDocTemplate
+        {
+            Name = "HVAC PM Completion",
+            ServiceKey = "HVAC PM",
+            WorkOrderType = WorkOrderType.PM,
+            TemplateUrl = "https://example.com/hvac.pdf",
+            IsActive = true
+        });
+        context.WorkOrderAuditLogs.Add(new WorkOrderAuditLog
+        {
+            WorkOrderId = 1,
+            EventType = "System",
+            Action = "WeekRolled",
+            FieldName = "CarriedOver",
+            OldValue = "0",
+            NewValue = "1",
+            CreatedAt = DateTime.UtcNow
+        });
+        context.Users.Add(new ApplicationUser
+        {
+            Id = "user-1",
+            UserName = "alice",
+            FirstName = "Alice",
+            LastName = "Dispatcher"
+        });
+        context.Comments.Add(new Comments
+        {
+            WorkerOrderId = 1,
+            UserId = "user-1",
+            Commenttext = "Called vendor",
+            CreatedDate = new DateTime(2026, 6, 1, 12, 0, 0, DateTimeKind.Utc)
+        });
+        await context.SaveChangesAsync();
+
+        var detail = await service.GetDetailAsync(1);
+
+        Assert.NotNull(detail);
+        Assert.True(detail!.Info.IsPastDue);
+        Assert.Equal("HVAC PM", detail.Info.Trade);
+        Assert.Equal("Leak", detail.Info.Description);
+        Assert.NotNull(detail.Completion.Template);
+        Assert.Equal("HVAC PM Completion", detail.Completion.Template!.Name);
+        Assert.Single(detail.Comments);
+        Assert.Equal("user-1", detail.Comments[0].AuthorId);
+        Assert.Equal("Alice Dispatcher", detail.Comments[0].AuthorName);
+        Assert.Equal("Called vendor", detail.Comments[0].Text);
+        Assert.Single(detail.Audit);
+        Assert.Equal("system", detail.Audit[0].Type);
+        Assert.Equal("WeekRolled", detail.Audit[0].Action);
+    }
+
+    [Fact]
+    public async Task GetAudit_ResolvesAssignToUserIdsToDisplayNames()
+    {
+        var (context, service) = CreateSut();
+        const string oldUserId = "a1000001-0001-4000-8000-000000000002";
+        const string newUserId = "b5e356d5-d926-4f92-8673-ee13cddeff0f";
+
+        context.Users.AddRange(
+            new ApplicationUser
+            {
+                Id = oldUserId,
+                UserName = "alice",
+                FirstName = "Alice",
+                LastName = "Dispatcher"
+            },
+            new ApplicationUser
+            {
+                Id = newUserId,
+                UserName = "bob",
+                FirstName = "Bob",
+                LastName = "Tech"
+            });
+        context.workOrders.Add(new WorkOrder
+        {
+            Id = 1,
+            InternalWONumber = "00000000001",
+            LifecycleStatus = LifecycleStatus.Pending,
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        });
+        context.WorkOrderAuditLogs.Add(new WorkOrderAuditLog
+        {
+            WorkOrderId = 1,
+            UserId = "actor-1",
+            EventType = "Manual",
+            Action = "AssignmentChanged",
+            FieldName = "AssignTo",
+            OldValue = oldUserId,
+            NewValue = newUserId,
+            CreatedAt = DateTime.UtcNow
+        });
+        context.WorkOrderAuditLogs.Add(new WorkOrderAuditLog
+        {
+            WorkOrderId = 1,
+            UserId = "actor-1",
+            EventType = "Manual",
+            Action = "AssignmentChanged",
+            FieldName = "AssignTo",
+            OldValue = newUserId,
+            NewValue = "",
+            CreatedAt = DateTime.UtcNow.AddMinutes(1)
+        });
+        await context.SaveChangesAsync();
+
+        var audit = await service.GetAuditAsync(1);
+
+        Assert.NotNull(audit);
+        Assert.Equal(2, audit!.Count);
+        var unassigned = audit.Single(a => a.NewValue == "Unassigned");
+        Assert.Equal("Bob Tech", unassigned.OldValue);
+        var reassigned = audit.Single(a => a.NewValue == "Bob Tech");
+        Assert.Equal("Alice Dispatcher", reassigned.OldValue);
+    }
+}
+
+public class WorkOrderCompletionServiceTests
+{
+    private static (ApplicationDbContext Context, WorkOrderCompletionService Service) CreateSut()
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+        var context = new ApplicationDbContext(options);
+        var templateData = new CompletionDocTemplateDataService(context);
+        var detailData = new WorkOrderDetailDataService(context);
+        var fieldLocks = new WorkOrderFieldLockService(context);
+        var audit = new WorkOrderAuditService(context, fieldLocks);
+        var service = new WorkOrderCompletionService(context, templateData, detailData, audit);
+        return (context, service);
+    }
+
+    [Fact]
+    public async Task UploadCompletionDoc_SetsDocStatusYesAndSignOff()
+    {
+        var (context, service) = CreateSut();
+        var wo = new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Scheduled,
+            Trade = "HVAC PM",
+            DocStatus = DocStatus.No,
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        };
+        context.workOrders.Add(wo);
+        await context.SaveChangesAsync();
+
+        var result = await service.UploadCompletionDocAsync(
+            1,
+            new WorkOrderCompletionDocUploadDto
+            {
+                SignOffName = "Jane Dispatcher",
+                WorkOrderVersion = Convert.ToBase64String(wo.RowVersion!)
+            },
+            "https://example.com/signed.pdf",
+            "actor-1");
+
+        Assert.Equal(DocStatus.Yes, result.DocStatus);
+        Assert.Equal("https://example.com/signed.pdf", result.SignOffAttachment);
+        Assert.Equal("Jane Dispatcher", result.SignOffName);
+
+        var updated = await context.workOrders.FindAsync(1);
+        Assert.Equal(DocStatus.Yes, updated!.DocStatus);
+        Assert.Equal(2, await context.WorkOrderAuditLogs.CountAsync());
+    }
+
+    [Fact]
+    public async Task UploadCompletionDoc_SecondUpload_DoesNotDuplicateFieldLocks()
+    {
+        var (context, service) = CreateSut();
+        var wo = new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Scheduled,
+            DocStatus = DocStatus.No,
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        };
+        context.workOrders.Add(wo);
+        await context.SaveChangesAsync();
+
+        var version = Convert.ToBase64String(wo.RowVersion!);
+        await service.UploadCompletionDocAsync(
+            1,
+            new WorkOrderCompletionDocUploadDto { WorkOrderVersion = version },
+            "https://example.com/first.pdf",
+            "actor-1");
+
+        // Simulate a new request scope: clear local tracker then reload
+        context.ChangeTracker.Clear();
+        var reloaded = await context.workOrders.SingleAsync(w => w.Id == 1);
+        // InMemory does not bump rowversion; keep same bytes for the second call
+        reloaded.RowVersion ??= new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 };
+
+        await service.UploadCompletionDocAsync(
+            1,
+            new WorkOrderCompletionDocUploadDto
+            {
+                WorkOrderVersion = Convert.ToBase64String(reloaded.RowVersion!)
+            },
+            "https://example.com/second.pdf",
+            "actor-1");
+
+        var locks = await context.WorkOrderFieldLocks.ToListAsync();
+        Assert.Equal(1, locks.Count(l => l.FieldName == "SignOffAttachment"));
+        Assert.Equal(1, locks.Count(l => l.FieldName == "DocStatus"));
+        Assert.Equal("https://example.com/second.pdf", reloaded.SignOffAttachment);
+    }
+
+    [Fact]
+    public async Task UploadCompletionDoc_MissingVersion_Throws()
+    {
+        var (context, service) = CreateSut();
+        context.workOrders.Add(new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Scheduled,
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        });
+        await context.SaveChangesAsync();
+
+        var ex = await Assert.ThrowsAsync<WorkOrderBoardValidationException>(() =>
+            service.UploadCompletionDocAsync(
+                1,
+                new WorkOrderCompletionDocUploadDto(),
+                "https://example.com/signed.pdf",
+                "actor-1"));
+
+        Assert.Equal("WorkOrderVersionRequired", ex.Code);
+    }
+
+    [Fact]
+    public async Task UploadCompletionDoc_ReadOnly_Throws()
+    {
+        var (context, service) = CreateSut();
+        context.workOrders.Add(new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Completed
+        });
+        await context.SaveChangesAsync();
+
+        var ex = await Assert.ThrowsAsync<WorkOrderBoardValidationException>(() =>
+            service.UploadCompletionDocAsync(
+                1,
+                new WorkOrderCompletionDocUploadDto
+                {
+                    WorkOrderVersion = Convert.ToBase64String(new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 })
+                },
+                "https://example.com/signed.pdf",
+                "actor-1"));
+
+        Assert.Equal("ReadOnly", ex.Code);
+    }
+}
+
+public class WorkOrderCommentServiceTests
+{
+    [Fact]
+    public async Task AddComment_ReturnsFeSchema()
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+        var context = new ApplicationDbContext(options);
+        context.workOrders.Add(new WorkOrder { Id = 1, LifecycleStatus = LifecycleStatus.Scheduled });
+        context.Users.Add(new ApplicationUser
+        {
+            Id = "user-abc",
+            UserName = "bob",
+            FirstName = "Bob",
+            LastName = "Tech"
+        });
+        await context.SaveChangesAsync();
+
+        var detailData = new WorkOrderDetailDataService(context);
+        var commentData = new CommentDataService(context);
+        var userData = new UserDataService(context);
+        var service = new WorkOrderCommentService(detailData, commentData, userData);
+
+        var result = await service.AddCommentAsync(1, new WorkOrderCommentCreateDto { Text = "Note" }, "user-abc");
+
+        Assert.Equal("user-abc", result.AuthorId);
+        Assert.Equal("Bob Tech", result.AuthorName);
+        Assert.Equal("Note", result.Text);
+        Assert.False(string.IsNullOrWhiteSpace(result.Time));
+    }
+
+    [Fact]
+    public async Task GetComments_FallsBackToCommenterWhenUserIdMissing()
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+        var context = new ApplicationDbContext(options);
+        context.workOrders.Add(new WorkOrder { Id = 1, LifecycleStatus = LifecycleStatus.Scheduled });
+        context.Comments.Add(new Comments
+        {
+            WorkerOrderId = 1,
+            Commenter = "Legacy Sync Author",
+            Commenttext = "Synced note",
+            CreatedDate = DateTime.UtcNow
+        });
+        await context.SaveChangesAsync();
+
+        var detailData = new WorkOrderDetailDataService(context);
+        var commentData = new CommentDataService(context);
+        var userData = new UserDataService(context);
+        var service = new WorkOrderCommentService(detailData, commentData, userData);
+
+        var comments = await service.GetCommentsAsync(1);
+
+        Assert.NotNull(comments);
+        Assert.Single(comments!);
+        Assert.Null(comments[0].AuthorId);
+        Assert.Equal("Legacy Sync Author", comments[0].AuthorName);
+        Assert.Equal("Synced note", comments[0].Text);
+    }
+
+    private static async Task<(ApplicationDbContext Context, WorkOrderCommentService Service, Comments Comment)> SeedEditableCommentAsync(
+        LifecycleStatus status = LifecycleStatus.Scheduled,
+        string authorId = "user-author",
+        string commentType = "General",
+        string recordType = "WorkOrder",
+        int workOrderId = 1)
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+        var context = new ApplicationDbContext(options);
+        context.workOrders.Add(new WorkOrder { Id = workOrderId, LifecycleStatus = status });
+        context.Users.Add(new ApplicationUser
+        {
+            Id = authorId,
+            UserName = "author",
+            FirstName = "Alice",
+            LastName = "Dispatcher"
+        });
+        var comment = new Comments
+        {
+            WorkerOrderId = workOrderId,
+            UserId = authorId,
+            Commenttext = "Original",
+            CommentType = commentType,
+            RecordType = recordType,
+            CreatedDate = DateTime.UtcNow
+        };
+        context.Comments.Add(comment);
+        await context.SaveChangesAsync();
+
+        var service = new WorkOrderCommentService(
+            new WorkOrderDetailDataService(context),
+            new CommentDataService(context),
+            new UserDataService(context));
+        return (context, service, comment);
+    }
+
+    [Fact]
+    public async Task UpdateComment_Author_UpdatesText()
+    {
+        var (_, service, comment) = await SeedEditableCommentAsync();
+
+        var result = await service.UpdateCommentAsync(
+            1,
+            comment.Id,
+            new WorkOrderCommentCreateDto { Text = "  Updated note  " },
+            "user-author",
+            isAdmin: false);
+
+        Assert.Equal("Updated note", result.Text);
+        Assert.Equal("user-author", result.AuthorId);
+        Assert.Equal("Alice Dispatcher", result.AuthorName);
+    }
+
+    [Fact]
+    public async Task UpdateComment_Admin_CanEditOthers()
+    {
+        var (_, service, comment) = await SeedEditableCommentAsync();
+
+        var result = await service.UpdateCommentAsync(
+            1,
+            comment.Id,
+            new WorkOrderCommentCreateDto { Text = "Admin edit" },
+            "admin-user",
+            isAdmin: true);
+
+        Assert.Equal("Admin edit", result.Text);
+        Assert.Equal("user-author", result.AuthorId);
+    }
+
+    [Fact]
+    public async Task UpdateComment_NonAuthorNonAdmin_ThrowsForbidden()
+    {
+        var (_, service, comment) = await SeedEditableCommentAsync();
+
+        var ex = await Assert.ThrowsAsync<WorkOrderBoardValidationException>(() =>
+            service.UpdateCommentAsync(
+                1,
+                comment.Id,
+                new WorkOrderCommentCreateDto { Text = "Nope" },
+                "other-user",
+                isAdmin: false));
+
+        Assert.Equal("Forbidden", ex.Code);
+    }
+
+    [Fact]
+    public async Task UpdateComment_LegacyVendorComment_ThrowsNotEditable()
+    {
+        var (_, service, comment) = await SeedEditableCommentAsync(
+            commentType: "vendor",
+            recordType: "WorkOrder");
+
+        var ex = await Assert.ThrowsAsync<WorkOrderBoardValidationException>(() =>
+            service.UpdateCommentAsync(
+                1,
+                comment.Id,
+                new WorkOrderCommentCreateDto { Text = "Nope" },
+                "user-author",
+                isAdmin: false));
+
+        Assert.Equal("NotEditable", ex.Code);
+    }
+
+    [Fact]
+    public async Task UpdateComment_ReadOnlyWorkOrder_Throws()
+    {
+        var (_, service, comment) = await SeedEditableCommentAsync(LifecycleStatus.Canceled);
+
+        var ex = await Assert.ThrowsAsync<WorkOrderBoardValidationException>(() =>
+            service.UpdateCommentAsync(
+                1,
+                comment.Id,
+                new WorkOrderCommentCreateDto { Text = "Nope" },
+                "user-author",
+                isAdmin: false));
+
+        Assert.Equal("ReadOnly", ex.Code);
+    }
+
+    [Fact]
+    public async Task UpdateComment_WrongWorkOrder_ThrowsNotFound()
+    {
+        var (context, service, comment) = await SeedEditableCommentAsync(workOrderId: 1);
+        context.workOrders.Add(new WorkOrder { Id = 2, LifecycleStatus = LifecycleStatus.Scheduled });
+        await context.SaveChangesAsync();
+
+        var ex = await Assert.ThrowsAsync<WorkOrderBoardValidationException>(() =>
+            service.UpdateCommentAsync(
+                2,
+                comment.Id,
+                new WorkOrderCommentCreateDto { Text = "Nope" },
+                "user-author",
+                isAdmin: false));
+
+        Assert.Equal("NotFound", ex.Code);
+    }
+}
+
+public class WorkOrderMediaServiceTests
+{
+    [Fact]
+    public async Task GetMedia_IncludesLegacyBeforeAfterAndExtra()
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+        var context = new ApplicationDbContext(options);
+        context.workOrders.Add(new WorkOrder
+        {
+            Id = 1,
+            BeforPhotoAttachment = "https://example.com/before.jpg",
+            AfterPhotoAttachment = "https://example.com/after.jpg"
+        });
+        context.workOrderAttachments.Add(new WorkOrderAttachments
+        {
+            WorkorderId = 1,
+            Attachments = "https://example.com/extra.pdf",
+            Category = WorkOrderMediaCategory.Extra
+        });
+        await context.SaveChangesAsync();
+
+        var detailData = new WorkOrderDetailDataService(context);
+        var service = new WorkOrderMediaService(context, detailData);
+        var media = await service.GetMediaAsync(1);
+
+        Assert.NotNull(media);
+        Assert.Equal(3, media!.Count);
+        Assert.Contains(media, m => m.Category == WorkOrderMediaCategory.Before);
+        Assert.Contains(media, m => m.Category == WorkOrderMediaCategory.After);
+        Assert.Contains(media, m => m.Category == WorkOrderMediaCategory.Extra);
+    }
+
+    [Fact]
+    public async Task DeleteMedia_ReadOnlyWorkOrder_Throws()
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+        var context = new ApplicationDbContext(options);
+        context.workOrders.Add(new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Completed
+        });
+        context.workOrderAttachments.Add(new WorkOrderAttachments
+        {
+            Id = 10,
+            WorkorderId = 1,
+            Attachments = "https://example.com/extra.pdf",
+            Category = WorkOrderMediaCategory.Extra
+        });
+        await context.SaveChangesAsync();
+
+        var service = new WorkOrderMediaService(context, new WorkOrderDetailDataService(context));
+        var ex = await Assert.ThrowsAsync<WorkOrderBoardValidationException>(() =>
+            service.DeleteMediaAsync(1, 10, "actor-1"));
+
+        Assert.Equal("ReadOnly", ex.Code);
+    }
+
+    [Fact]
+    public async Task AddMedia_CompletionCategory_ThrowsUseCompletionDocEndpoint()
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+        var context = new ApplicationDbContext(options);
+        context.workOrders.Add(new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Scheduled
+        });
+        await context.SaveChangesAsync();
+
+        var service = new WorkOrderMediaService(context, new WorkOrderDetailDataService(context));
+        var ex = await Assert.ThrowsAsync<WorkOrderBoardValidationException>(() =>
+            service.AddMediaAsync(1, WorkOrderMediaCategory.Completion, "https://example.com/doc.pdf", "actor-1"));
+
+        Assert.Equal("UseCompletionDocEndpoint", ex.Code);
+    }
+}
diff --git a/SeaHavenIndustries.Tests/WorkOrderPhase7CoexistenceTests.cs b/SeaHavenIndustries.Tests/WorkOrderPhase7CoexistenceTests.cs
new file mode 100644
index 0000000..d3c0764
--- /dev/null
+++ b/SeaHavenIndustries.Tests/WorkOrderPhase7CoexistenceTests.cs
@@ -0,0 +1,241 @@
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Options;
+using SeaHaven.DataServices.Implementation;
+using SeaHaven.Services.DTOs;
+using SeaHaven.Services.Helpers;
+using SeaHaven.Services.Implementation;
+using SeaHaven.Services.Interfaces;
+using SeaHaven.Services.Validation;
+
+namespace SeaHavenIndustries.Tests;
+
+public class WorkOrderPhase7CoexistenceTests
+{
+    [Fact]
+    public void IngestFieldMapper_MapsDynamoStatus()
+    {
+        Assert.Equal("Open", WorkOrderIngestFieldMapper.MapStatus("new"));
+        Assert.Equal("In Progress", WorkOrderIngestFieldMapper.MapStatus("in_progress"));
+        Assert.Equal("Done", WorkOrderIngestFieldMapper.MapStatus("completed"));
+    }
+
+    [Fact]
+    public async Task IngestService_CreatesThenUpdates_IdempotentByExternalId()
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+        await using var context = new ApplicationDbContext(options);
+
+        var fieldLocks = new WorkOrderFieldLockService(context);
+        var audit = new WorkOrderAuditService(context, fieldLocks);
+        var ingest = new WorkOrderIngestService(context, new SyncFieldMergePolicy(fieldLocks), fieldLocks, audit);
+
+        var payload = new WorkOrderIngestPayloadDto
+        {
+            ExternalWorkOrderId = "ext-100",
+            Description = "Initial",
+            WoStatus = "new",
+            Severity = "2",
+            SiteCode = "BK1"
+        };
+
+        var create = await ingest.UpsertBatchAsync(new[] { payload });
+        Assert.Equal(1, create.Created);
+        Assert.Equal(0, create.Updated);
+
+        payload.Description = "Updated via ingest";
+        var update = await ingest.UpsertBatchAsync(new[] { payload });
+        Assert.Equal(0, update.Created);
+        Assert.Equal(1, update.Updated);
+
+        var wo = await context.workOrders.SingleAsync();
+        Assert.Equal("Updated via ingest", wo.Description);
+        Assert.Equal("ext-100", wo.ExternalWorkOrderId);
+    }
+
+    [Fact]
+    public async Task IngestRespectsFieldLock_AfterShocBoardCreate()
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+        await using var context = new ApplicationDbContext(options);
+
+        var boardData = new WorkOrderBoardDataService(context);
+        var boardService = new WorkOrderBoardService(boardData);
+        var fieldLocks = new WorkOrderFieldLockService(context);
+        var audit = new WorkOrderAuditService(context, fieldLocks);
+        var createService = new WorkOrderBoardCreateService(
+            context, boardData, boardService, audit, new WorkOrderBoardCreateValidation());
+        var policy = new SyncFieldMergePolicy(fieldLocks);
+        var ingest = new WorkOrderIngestService(context, policy, fieldLocks, audit);
+
+        await createService.CreateAsync(new WorkOrderBoardCreateRequestDto
+        {
+            WorkOrderType = WorkOrderType.PM,
+            SiteCode = "BK5"
+        }, "dispatcher-1");
+
+        var wo = await context.workOrders.SingleAsync();
+        wo.ExternalWorkOrderId = "ext-shoc-1";
+        await context.SaveChangesAsync();
+
+        await ingest.UpsertBatchAsync(new[]
+        {
+            new WorkOrderIngestPayloadDto
+            {
+                ExternalWorkOrderId = "ext-shoc-1",
+                SiteCode = "SYNC-SITE"
+            }
+        });
+
+        Assert.Equal("BK5", wo.SiteCode);
+        Assert.True(await context.WorkOrderAuditLogs.AnyAsync(l => l.Action == "SyncRejected"));
+    }
+
+    [Fact]
+    public async Task IngestRespectsLocationIdFieldLock()
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+        await using var context = new ApplicationDbContext(options);
+
+        context.Locations.Add(new Locations { Id = 1, Name = "BK1", Status = "Active" });
+        context.Locations.Add(new Locations { Id = 2, Name = "BK2", Status = "Active" });
+        context.workOrders.Add(new WorkOrder
+        {
+            Id = 10,
+            ExternalWorkOrderId = "ext-loc-1",
+            LocationId = 1,
+            SiteCode = "BK1",
+            istemplate = false
+        });
+        context.WorkOrderFieldLocks.Add(new WorkOrderFieldLock
+        {
+            WorkOrderId = 10,
+            FieldName = "LocationId",
+            LockedAt = DateTime.UtcNow,
+            LockedByUserId = "dispatcher-1"
+        });
+        await context.SaveChangesAsync();
+
+        var fieldLocks = new WorkOrderFieldLockService(context);
+        var audit = new WorkOrderAuditService(context, fieldLocks);
+        var ingest = new WorkOrderIngestService(context, new SyncFieldMergePolicy(fieldLocks), fieldLocks, audit);
+
+        await ingest.UpsertBatchAsync(new[]
+        {
+            new WorkOrderIngestPayloadDto
+            {
+                ExternalWorkOrderId = "ext-loc-1",
+                SiteCode = "BK2",
+                Building = "BK2"
+            }
+        });
+
+        var wo = await context.workOrders.SingleAsync(w => w.Id == 10);
+        Assert.Equal(1, wo.LocationId);
+        Assert.True(await context.WorkOrderAuditLogs.AnyAsync(l =>
+            l.Action == "SyncRejected" && l.FieldName == "LocationId"));
+    }
+
+    [Fact]
+    public async Task IngestBatch_SkipsItemsWithoutExternalId()
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+        await using var context = new ApplicationDbContext(options);
+
+        var fieldLocks = new WorkOrderFieldLockService(context);
+        var audit = new WorkOrderAuditService(context, fieldLocks);
+        var ingest = new WorkOrderIngestService(context, new SyncFieldMergePolicy(fieldLocks), fieldLocks, audit);
+
+        var result = await ingest.UpsertBatchAsync(new[]
+        {
+            new WorkOrderIngestPayloadDto { ExternalWorkOrderId = "   ", Description = "bad" },
+            new WorkOrderIngestPayloadDto { ExternalWorkOrderId = "ext-ok", Description = "good" }
+        });
+
+        Assert.Equal(1, result.Created);
+        Assert.Equal(1, result.Skipped);
+        Assert.Equal(1, result.Results.Count);
+        Assert.Equal("ext-ok", result.Results[0].ExternalWorkOrderId);
+    }
+
+    [Fact]
+    public async Task OpsHealth_ReturnsCoexistenceMetrics()
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+        await using var context = new ApplicationDbContext(options);
+
+        context.WorkOrderFieldLocks.Add(new WorkOrderFieldLock
+        {
+            WorkOrderId = 1,
+            FieldName = "SiteCode",
+            LockedAt = DateTime.UtcNow,
+            LockedByUserId = "u1"
+        });
+        context.WorkOrderAuditLogs.Add(new WorkOrderAuditLog
+        {
+            WorkOrderId = 1,
+            Action = "SyncRejected",
+            FieldName = "Description",
+            CreatedAt = DateTime.UtcNow.AddHours(-1)
+        });
+        await context.SaveChangesAsync();
+
+        var runState = new WorkOrderJobRunStateAccessor
+        {
+            State = { LastWeekRolledRunUtc = DateTime.UtcNow.AddDays(-1) }
+        };
+
+        var healthOptions = Options.Create(new WorkOrderOpsHealthOptions
+        {
+            SyncEnabled = true,
+            IngestEnabled = true,
+            LegacyDeprecationEnabled = true,
+            LegacySunsetDate = "2026-12-31"
+        });
+
+        var service = new WorkOrderOpsHealthService(context, runState, healthOptions);
+        var health = await service.GetHealthAsync();
+
+        Assert.Equal(1, health.FieldLockCount);
+        Assert.Equal(1, health.SyncRejectedLast24h);
+        Assert.True(health.SyncEnabled);
+        Assert.True(health.IngestEnabled);
+        Assert.Equal("2026-12-31", health.LegacySunsetDate);
+    }
+
+    [Fact]
+    public async Task BoardAndLegacyEndpoints_CanCoexist_InSameDatabase()
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+        await using var context = new ApplicationDbContext(options);
+
+        context.workOrders.Add(new WorkOrder
+        {
+            WorkerOrderTitle = "Legacy row",
+            Status = "Open",
+            InternalWONumber = "10000001",
+            istemplate = false
+        });
+        await context.SaveChangesAsync();
+
+        var boardData = new WorkOrderBoardDataService(context);
+        var boardService = new WorkOrderBoardService(boardData);
+        var count = await context.workOrders.CountAsync();
+
+        Assert.Equal(1, count);
+        Assert.NotNull(boardService);
+    }
+}
diff --git a/SeaHavenIndustries.Tests/WorkOrderTypeMapperTests.cs b/SeaHavenIndustries.Tests/WorkOrderTypeMapperTests.cs
new file mode 100644
index 0000000..b25bcd5
--- /dev/null
+++ b/SeaHavenIndustries.Tests/WorkOrderTypeMapperTests.cs
@@ -0,0 +1,32 @@
+using Data.SeaHavenIndustries.Enums;
+using SeaHaven.Services.Helpers;
+
+namespace SeaHavenIndustries.Tests;
+
+public class WorkOrderTypeMapperTests
+{
+    [Theory]
+    [InlineData("PM", WorkOrderType.PM)]
+    [InlineData("Reactive", WorkOrderType.Reactive)]
+    [InlineData("Emergency", WorkOrderType.Emergency)]
+    [InlineData("Add-On", WorkOrderType.AddOn)]
+    public void TryParseFeLabel_BoardTypes(string label, WorkOrderType expected)
+    {
+        Assert.True(WorkOrderTypeMapper.TryParseFeLabel(label, out var type));
+        Assert.Equal(expected, type);
+    }
+
+    [Fact]
+    public void TryParseFeLabel_Overdue_ReturnsFalse()
+    {
+        Assert.False(WorkOrderTypeMapper.TryParseFeLabel("Overdue", out _));
+    }
+
+    [Theory]
+    [InlineData(WorkOrderType.AddOn, "Add-On")]
+    [InlineData(WorkOrderType.Reactive, "Reactive")]
+    public void ToFeLabel_ReturnsBoardLabel(WorkOrderType type, string expected)
+    {
+        Assert.Equal(expected, WorkOrderTypeMapper.ToFeLabel(type));
+    }
+}
diff --git a/SeaHavenIndustries.Tests/WorkOrderWeekRolledTests.cs b/SeaHavenIndustries.Tests/WorkOrderWeekRolledTests.cs
new file mode 100644
index 0000000..4aef509
--- /dev/null
+++ b/SeaHavenIndustries.Tests/WorkOrderWeekRolledTests.cs
@@ -0,0 +1,347 @@
+using Data.SeaHavenIndustries;
+using Data.SeaHavenIndustries.Enums;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Diagnostics;
+using Microsoft.Extensions.Logging.Abstractions;
+using SeaHaven.DataServices.Implementation;
+using SeaHaven.Services.Helpers;
+using SeaHaven.Services.Implementation;
+using SeaHaven.Services.Interfaces;
+
+namespace SeaHavenIndustries.Tests;
+
+public class WorkOrderWeekRolledTests
+{
+    private static readonly DateOnly SourceWeekStart = new(2026, 6, 16);
+    private static readonly DateOnly SourceWeekEnd = new(2026, 6, 20);
+
+    private static ApplicationDbContext CreateContext()
+    {
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .ConfigureWarnings(w => w.Ignore(InMemoryEventId.TransactionIgnoredWarning))
+            .Options;
+        return new ApplicationDbContext(options);
+    }
+
+    private static WorkOrderWeekRolledService CreateService(ApplicationDbContext context)
+    {
+        var dataService = new WorkOrderDomainJobDataService(context);
+        var audit = new WorkOrderAuditService(context, new WorkOrderFieldLockService(context));
+        return new WorkOrderWeekRolledService(
+            dataService,
+            audit,
+            NullLogger<WorkOrderWeekRolledService>.Instance);
+    }
+
+    [Fact]
+    public async Task WeekRolled_IncrementsCarriedOver_ForEligibleWo()
+    {
+        await using var context = CreateContext();
+        context.workOrders.Add(new WorkOrder
+        {
+            Id = 1,
+            ScheduledDate = new DateTime(2026, 6, 18),
+            LifecycleStatus = LifecycleStatus.Scheduled,
+            CarriedOver = 0
+        });
+        await context.SaveChangesAsync();
+
+        var service = CreateService(context);
+        var result = await service.ProcessWeekRolledAsync(SourceWeekStart);
+
+        Assert.Equal(1, result.Processed);
+        Assert.Equal(0, result.Skipped);
+        Assert.Equal(0, result.Failed);
+
+        var wo = await context.workOrders.FindAsync(1);
+        Assert.Equal(1, wo!.CarriedOver);
+    }
+
+    [Fact]
+    public async Task WeekRolled_SkipsTerminalStatuses()
+    {
+        await using var context = CreateContext();
+        context.workOrders.AddRange(
+            new WorkOrder
+            {
+                Id = 1,
+                ScheduledDate = new DateTime(2026, 6, 18),
+                LifecycleStatus = LifecycleStatus.Completed
+            },
+            new WorkOrder
+            {
+                Id = 2,
+                ScheduledDate = new DateTime(2026, 6, 18),
+                LifecycleStatus = LifecycleStatus.Canceled
+            });
+        await context.SaveChangesAsync();
+
+        var service = CreateService(context);
+        var result = await service.ProcessWeekRolledAsync(SourceWeekStart);
+
+        Assert.Equal(0, result.Processed);
+        Assert.Equal(0, result.Failed);
+    }
+
+    [Fact]
+    public async Task WeekRolled_Idempotent_SecondRunSkips()
+    {
+        await using var context = CreateContext();
+        context.workOrders.Add(new WorkOrder
+        {
+            Id = 1,
+            ScheduledDate = new DateTime(2026, 6, 18),
+            LifecycleStatus = LifecycleStatus.Scheduled,
+            CarriedOver = 0
+        });
+        await context.SaveChangesAsync();
+
+        var service = CreateService(context);
+        var first = await service.ProcessWeekRolledAsync(SourceWeekStart);
+        var second = await service.ProcessWeekRolledAsync(SourceWeekStart);
+
+        Assert.Equal(1, first.Processed);
+        Assert.Equal(0, second.Processed);
+        Assert.Equal(0, second.Failed);
+
+        var wo = await context.workOrders.FindAsync(1);
+        Assert.Equal(1, wo!.CarriedOver);
+    }
+
+    [Fact]
+    public async Task WeekRolled_WritesAuditEvent()
+    {
+        await using var context = CreateContext();
+        context.workOrders.Add(new WorkOrder
+        {
+            Id = 1,
+            ScheduledDate = new DateTime(2026, 6, 18),
+            LifecycleStatus = LifecycleStatus.InProgress,
+            CarriedOver = 2
+        });
+        await context.SaveChangesAsync();
+
+        var service = CreateService(context);
+        await service.ProcessWeekRolledAsync(SourceWeekStart);
+
+        var logs = await context.WorkOrderAuditLogs.ToListAsync();
+        Assert.Single(logs);
+        Assert.Equal("WeekRolled", logs[0].Action);
+        Assert.Equal("System", logs[0].EventType);
+        Assert.Equal("System", logs[0].ActorType);
+        Assert.Equal("CarriedOver", logs[0].FieldName);
+        Assert.Equal("2", logs[0].OldValue);
+        Assert.Equal("3", logs[0].NewValue);
+        Assert.Equal("week:2026-06-16", logs[0].CorrelationId);
+
+        var locks = await context.WorkOrderFieldLocks.ToListAsync();
+        Assert.Empty(locks);
+    }
+
+    [Fact]
+    public async Task WeekRolled_ConcurrentWithReschedule_DoesNotDuplicate()
+    {
+        await using var context = CreateContext();
+        context.workOrders.Add(new WorkOrder
+        {
+            Id = 1,
+            ScheduledDate = new DateTime(2026, 6, 18),
+            LifecycleStatus = LifecycleStatus.Scheduled,
+            CarriedOver = 0
+        });
+        await context.SaveChangesAsync();
+
+        var dataService = new WorkOrderDomainJobDataService(context);
+        var correlationId = WorkOrderOperationalWeek.BuildWeekCorrelationId(SourceWeekStart);
+
+        var first = await dataService.TryProcessWeekRolledAsync(1, SourceWeekStart, correlationId);
+        var second = await dataService.TryProcessWeekRolledAsync(1, SourceWeekStart, correlationId);
+
+        Assert.True(first.Processed);
+        Assert.True(second.Skipped);
+
+        var wo = await context.workOrders.FindAsync(1);
+        Assert.Equal(1, wo!.CarriedOver);
+    }
+
+    [Fact]
+    public async Task WeekRolled_FailureReRun_IsSafeAfterPartialLedger()
+    {
+        await using var context = CreateContext();
+        context.workOrders.Add(new WorkOrder
+        {
+            Id = 1,
+            ScheduledDate = new DateTime(2026, 6, 18),
+            LifecycleStatus = LifecycleStatus.Scheduled,
+            CarriedOver = 0
+        });
+        await context.SaveChangesAsync();
+
+        var dataService = new WorkOrderDomainJobDataService(context);
+        var correlationId = WorkOrderOperationalWeek.BuildWeekCorrelationId(SourceWeekStart);
+
+        await dataService.TryProcessWeekRolledAsync(1, SourceWeekStart, correlationId);
+
+        var service = CreateService(context);
+        var rerun = await service.ProcessWeekRolledAsync(SourceWeekStart);
+
+        Assert.Equal(0, rerun.Processed);
+        Assert.Equal(0, rerun.Failed);
+
+        var wo = await context.workOrders.FindAsync(1);
+        Assert.Equal(1, wo!.CarriedOver);
+    }
+
+    [Fact]
+    public async Task WeekRolled_ProcessesAllEligible_WhenMoreThanBatchSize()
+    {
+        // WorkOrderWeekRolledService.BatchSize is 500; more than one page must all be carried over.
+        const int eligibleCount = 501;
+
+        await using var context = CreateContext();
+        for (var i = 1; i <= eligibleCount; i++)
+        {
+            context.workOrders.Add(new WorkOrder
+            {
+                Id = i,
+                ScheduledDate = new DateTime(2026, 6, 18),
+                LifecycleStatus = LifecycleStatus.Scheduled,
+                CarriedOver = 0
+            });
+        }
+        await context.SaveChangesAsync();
+
+        var service = CreateService(context);
+        var result = await service.ProcessWeekRolledAsync(SourceWeekStart);
+
+        Assert.Equal(eligibleCount, result.Processed);
+        Assert.Equal(0, result.Skipped);
+        Assert.Equal(0, result.Failed);
+
+        var carriedOverCount = await context.workOrders.CountAsync(w => w.CarriedOver == 1);
+        Assert.Equal(eligibleCount, carriedOverCount);
+
+        var ledgerCount = await context.WorkOrderWeekRolledLedgers.CountAsync();
+        Assert.Equal(eligibleCount, ledgerCount);
+
+        var auditCount = await context.WorkOrderAuditLogs.CountAsync(l => l.Action == "WeekRolled");
+        Assert.Equal(eligibleCount, auditCount);
+    }
+
+    [Fact]
+    public async Task PastDueCache_SyncsOperationalFlags()
+    {
+        await using var context = CreateContext();
+        var pastDate = DateTime.UtcNow.Date.AddDays(-3);
+        var futureDate = DateTime.UtcNow.Date.AddDays(3);
+
+        context.workOrders.AddRange(
+            new WorkOrder
+            {
+                Id = 1,
+                ScheduledDate = pastDate,
+                LifecycleStatus = LifecycleStatus.Scheduled
+            },
+            new WorkOrder
+            {
+                Id = 2,
+                ScheduledDate = pastDate,
+                LifecycleStatus = LifecycleStatus.Completed,
+                OperationalFlags = OperationalFlags.PastDue
+            },
+            new WorkOrder
+            {
+                Id = 3,
+                ScheduledDate = futureDate,
+                LifecycleStatus = LifecycleStatus.Scheduled,
+                OperationalFlags = OperationalFlags.PastDue
+            });
+        await context.SaveChangesAsync();
+
+        var dataService = new WorkOrderDomainJobDataService(context);
+        var result = await dataService.RefreshPastDueFlagsAsync(DateTime.UtcNow);
+
+        Assert.Equal(1, result.SetCount);
+        Assert.Equal(2, result.ClearedCount);
+
+        var wo1 = await context.workOrders.FindAsync(1);
+        var wo2 = await context.workOrders.FindAsync(2);
+        var wo3 = await context.workOrders.FindAsync(3);
+
+        Assert.True(wo1!.OperationalFlags.HasFlag(OperationalFlags.PastDue));
+        Assert.False(wo2!.OperationalFlags.HasFlag(OperationalFlags.PastDue));
+        Assert.False(wo3!.OperationalFlags.HasFlag(OperationalFlags.PastDue));
+    }
+
+    [Fact]
+    public async Task Board_ReflectsCarriedOver_AfterWeekRolled()
+    {
+        await using var context = CreateContext();
+        context.workOrders.Add(new WorkOrder
+        {
+            Id = 1,
+            ScheduledDate = new DateTime(2026, 6, 18),
+            LifecycleStatus = LifecycleStatus.Scheduled,
+            CarriedOver = 0
+        });
+        await context.SaveChangesAsync();
+
+        var service = CreateService(context);
+        await service.ProcessWeekRolledAsync(SourceWeekStart);
+
+        var boardData = new WorkOrderBoardDataService(context);
+        var boardService = new WorkOrderBoardService(boardData);
+        var row = await boardService.GetBoardRowAsync(1);
+
+        Assert.NotNull(row);
+        Assert.Equal(1, row!.CarriedOver);
+    }
+
+    [Fact]
+    public async Task Board_IsPastDue_UnaffectedByCache()
+    {
+        await using var context = CreateContext();
+        var pastDate = DateTime.UtcNow.Date.AddDays(-2);
+
+        context.workOrders.Add(new WorkOrder
+        {
+            Id = 1,
+            ScheduledDate = pastDate,
+            LifecycleStatus = LifecycleStatus.Scheduled,
+            OperationalFlags = OperationalFlags.None
+        });
+        await context.SaveChangesAsync();
+
+        var boardData = new WorkOrderBoardDataService(context);
+        var boardService = new WorkOrderBoardService(boardData);
+        var row = await boardService.GetBoardRowAsync(1);
+
+        Assert.NotNull(row);
+        Assert.True(row!.IsPastDue);
+        Assert.False(WorkOrderDerivedFields.IsPastDue(pastDate, LifecycleStatus.Scheduled) == false);
+    }
+
+    [Fact]
+    public async Task Board_IsPastDue_IgnoresStalePastDueFlag()
+    {
+        await using var context = CreateContext();
+        var futureDate = DateTime.UtcNow.Date.AddDays(5);
+
+        context.workOrders.Add(new WorkOrder
+        {
+            Id = 1,
+            ScheduledDate = futureDate,
+            LifecycleStatus = LifecycleStatus.Scheduled,
+            OperationalFlags = OperationalFlags.PastDue
+        });
+        await context.SaveChangesAsync();
+
+        var boardData = new WorkOrderBoardDataService(context);
+        var boardService = new WorkOrderBoardService(boardData);
+        var row = await boardService.GetBoardRowAsync(1);
+
+        Assert.NotNull(row);
+        Assert.False(row!.IsPastDue);
+    }
+}
diff --git a/SeaHavenIndustries.sln b/SeaHavenIndustries.sln
index 429aed6..c814615 100644
--- a/SeaHavenIndustries.sln
+++ b/SeaHavenIndustries.sln
@@ -17,6 +17,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Api.SeaHavenIndustries.Test
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SeaHaven.Services.Tests", "SeaHaven.Services.Tests\SeaHaven.Services.Tests.csproj", "{97455198-C479-47F2-8BC8-601B335DFFAB}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SeaHavenIndustries.Tests", "SeaHavenIndustries.Tests\SeaHavenIndustries.Tests.csproj", "{0093B3F5-0180-4C02-A088-6A564E06CEBF}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -51,6 +53,10 @@ Global
 		{97455198-C479-47F2-8BC8-601B335DFFAB}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{97455198-C479-47F2-8BC8-601B335DFFAB}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{97455198-C479-47F2-8BC8-601B335DFFAB}.Release|Any CPU.Build.0 = Release|Any CPU
+		{0093B3F5-0180-4C02-A088-6A564E06CEBF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{0093B3F5-0180-4C02-A088-6A564E06CEBF}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{0093B3F5-0180-4C02-A088-6A564E06CEBF}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{0093B3F5-0180-4C02-A088-6A564E06CEBF}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
diff --git a/SeaHavenIndustries/Data/Services/WorkorderService.cs b/SeaHavenIndustries/Data/Services/WorkorderService.cs
index f616377..2e18cf2 100644
--- a/SeaHavenIndustries/Data/Services/WorkorderService.cs
+++ b/SeaHavenIndustries/Data/Services/WorkorderService.cs
@@ -22,14 +22,22 @@ namespace SeaHavenIndustries.Data.Services
         private UserManager<ApplicationUser> _userManager;
         private UploadFileHp _uploadFileHelper;
         private readonly SendMessage _sendemail;
+        private readonly BlazorWorkOrderSunsetGuard _sunsetGuard;
 
-        public WorkorderService(SendMessage sendemail, ApplicationDbContext context, IHttpContextAccessor httpContextAccessor, UserManager<ApplicationUser> userManager, UploadFileHp uploadFileHelper)
+        public WorkorderService(
+            SendMessage sendemail,
+            ApplicationDbContext context,
+            IHttpContextAccessor httpContextAccessor,
+            UserManager<ApplicationUser> userManager,
+            UploadFileHp uploadFileHelper,
+            BlazorWorkOrderSunsetGuard sunsetGuard)
         {
             _context = context;
             _httpContextAccessor = httpContextAccessor;
             _userManager = userManager;
             _uploadFileHelper = uploadFileHelper;
             _sendemail = sendemail;
+            _sunsetGuard = sunsetGuard;
         }
         public async Task<List<WorkOrder>> Getworkorder()
         {
@@ -178,6 +186,7 @@ namespace SeaHavenIndustries.Data.Services
         }
         public async Task<string> Addworkorder(WorkOrder model, List<FileUploadViewModel> files)
         {
+            _sunsetGuard.ThrowIfMutationsBlocked();
             try
             {
                 _context.ChangeTracker.Clear();
@@ -425,6 +434,7 @@ namespace SeaHavenIndustries.Data.Services
         }
         public async Task<string> Deleteworkorder(int id)
         {
+            _sunsetGuard.ThrowIfMutationsBlocked();
             _context.ChangeTracker.Clear();
 
             try
diff --git a/SeaHavenIndustries/Helper/BlazorWorkOrderSunsetGuard.cs b/SeaHavenIndustries/Helper/BlazorWorkOrderSunsetGuard.cs
new file mode 100644
index 0000000..5c7bbf8
--- /dev/null
+++ b/SeaHavenIndustries/Helper/BlazorWorkOrderSunsetGuard.cs
@@ -0,0 +1,26 @@
+using Microsoft.Extensions.Options;
+using SeaHavenIndustries.Options;
+
+namespace SeaHavenIndustries.Helper
+{
+    public class BlazorWorkOrderSunsetGuard
+    {
+        private readonly BlazorWorkOrderSunsetOptions _options;
+
+        public BlazorWorkOrderSunsetGuard(IOptions<BlazorWorkOrderSunsetOptions> options)
+        {
+            _options = options.Value;
+        }
+
+        public bool IsSunsetEnabled => _options.Enabled;
+
+        public string ShocBaseUrl => _options.ShocBaseUrl.TrimEnd('/');
+
+        public void ThrowIfMutationsBlocked()
+        {
+            if (_options.Enabled)
+                throw new InvalidOperationException(
+                    "Work Orders module has moved to SHOC. Editing via Blazor is disabled.");
+        }
+    }
+}
diff --git a/SeaHavenIndustries/Options/BlazorWorkOrderSunsetOptions.cs b/SeaHavenIndustries/Options/BlazorWorkOrderSunsetOptions.cs
new file mode 100644
index 0000000..e368d9f
--- /dev/null
+++ b/SeaHavenIndustries/Options/BlazorWorkOrderSunsetOptions.cs
@@ -0,0 +1,11 @@
+namespace SeaHavenIndustries.Options
+{
+    public class BlazorWorkOrderSunsetOptions
+    {
+        public const string SectionName = "BlazorWorkOrderSunset";
+
+        public bool Enabled { get; set; }
+
+        public string ShocBaseUrl { get; set; } = "https://shoc.seahaven.com";
+    }
+}
diff --git a/SeaHavenIndustries/Program.cs b/SeaHavenIndustries/Program.cs
index 5450abf..48b76c3 100644
--- a/SeaHavenIndustries/Program.cs
+++ b/SeaHavenIndustries/Program.cs
@@ -77,6 +77,9 @@ builder.Services.AddScoped<UploadFileHp>();
 builder.Services.AddScoped<NorthwindService>();
 builder.Services.AddScoped<SendMessage>();
 builder.Services.AddScoped<PdfService>();
+builder.Services.Configure<SeaHavenIndustries.Options.BlazorWorkOrderSunsetOptions>(
+    builder.Configuration.GetSection(SeaHavenIndustries.Options.BlazorWorkOrderSunsetOptions.SectionName));
+builder.Services.AddSingleton<BlazorWorkOrderSunsetGuard>();
 
 builder.Services.AddSession(options =>
 {
diff --git a/SeaHavenIndustries/appsettings.json b/SeaHavenIndustries/appsettings.json
index 78d143e..fa26bef 100644
--- a/SeaHavenIndustries/appsettings.json
+++ b/SeaHavenIndustries/appsettings.json
@@ -1,10 +1,5 @@
 {
   "ConnectionStrings": {
-    //"DefaultConnection": "Server=.;Database=SeahavenIndustries;TrustServerCertificate=True;Trusted_Connection=True;MultipleActiveResultSets=true",
-    //"DefaultConnection": "Server=.\\SqlExpress;Database=SeahavenIndustries;TrustServerCertificate=True;Trusted_Connection=True;MultipleActiveResultSets=true",
-
-    // Provide the real value via environment variable ConnectionStrings__DefaultConnection,
-    // user-secrets, or appsettings.Development.json (which is gitignored). Do NOT commit credentials.
     "DefaultConnection": "${CONNECTION_STRING}",
     "excelconnection": "Provider=Microsoft.ACE.OLEDB.12.0;Data Source={0};Extended Properties='Excel 8.0;HDR=YES'"
   },
@@ -15,12 +10,14 @@
     }
   },
   "SendGrid": {
-    // Provide the real value via environment variable SendGrid__ApiKey or user-secrets.
     "ApiKey": "${SENDGRID_API_KEY}"
   },
   "GoogleMaps": {
-    // Provide the real value via environment variable GoogleMaps__ApiKey or user-secrets.
     "ApiKey": "${GOOGLE_MAPS_API_KEY}"
   },
-  "AllowedHosts": "*"
+  "AllowedHosts": "*",
+  "BlazorWorkOrderSunset": {
+    "Enabled": false,
+    "ShocBaseUrl": "https://shoc.seahaven.com"
+  }
 }
diff --git a/docs/adr/work-orders-board-api.md b/docs/adr/work-orders-board-api.md
new file mode 100644
index 0000000..9501406
--- /dev/null
+++ b/docs/adr/work-orders-board-api.md
@@ -0,0 +1,194 @@
+# ADR: Work Orders Board API (Fase 1 read-only)
+
+**Status:** Proposed — spikes G0, G1, G3 concluídas  
+**Data:** 2026-06-19  
+**Deciders:** Backend + FE (aprovação Fase 1 pending)
+
+---
+
+## Contexto
+
+O Schedule Board (FE) organiza work orders por `ScheduledDate` em visão semanal. O backend atual expõe `GetWorkOrderList` — listagem CRUD paginada sem janela temporal, sem `siteCode`, sem vendor inline, sem `ScheduledDate` na projeção.
+
+Spikes de referência:
+
+- [Consumer Audit](../spikes/consumer-audit-getworkorderlist.md)
+- [WorkOrderType](../spikes/work-order-type.md)
+- [Search Strategy](../spikes/search-strategy.md)
+
+---
+
+## Decisão
+
+### 1. Endpoint dedicado (sem `projection=`)
+
+Criar endpoint **separado** para o Schedule Board. **Não alterar** `GetWorkOrderList`.
+
+```http
+GET /api/workorders/GetWorkOrdersBoard
+    ?scheduledFrom=2026-06-01
+    &scheduledTo=2026-06-07
+    &assignee=guid1&assignee=guid2
+    &search=BK5
+    &status=Open&status=InProgress
+    &locationId=42
+```
+
+Rota alias: `GET /api/WorkOrder/GetWorkOrdersBoard` (consistente com controller existente).
+
+**Rejeitado:**
+
+- `GET /api/workorders/table`
+- `GET /GetWorkOrderList?projection=table`
+
+### 2. Window-based fetch (sem paginação Fase 1)
+
+| Abordagem | Fase 1 |
+|-----------|--------|
+| `scheduledFrom` + `scheduledTo` | **Obrigatório** |
+| `page` / `pageSize` | **Ausente** |
+| Limite janela | Max **90 dias** (validação server-side) |
+
+Response envelope:
+
+```json
+{
+  "scheduledFrom": "2026-06-01",
+  "scheduledTo": "2026-06-07",
+  "totalCount": 42,
+  "items": [
+    {
+      "row": { /* WorkOrderBoardRowDto */ },
+      "presentation": { /* BoardRowPresentation */ }
+    }
+  ]
+}
+```
+
+### 3. DTO — domínio vs presentation
+
+**`WorkOrderBoardRowDto`** — dados persistidos / joináveis:
+
+```csharp
+public record WorkOrderBoardRowDto(
+    int Id,
+    string? WoNumber,
+    string? SiteCode,
+    string? LocationLabel,
+    DateOnly? ScheduledDate,
+    TimeOnly? ScheduledStart,
+    DateOnly? DueDate,
+    string? WorkOrderType,
+    string? ServiceType,
+    string? AssigneeId,
+    string? AssigneeName,
+    string? VendorCompany,
+    string? VendorTechnician,
+    string Status,
+    string? PocName,
+    string? PocPhone
+);
+```
+
+**`BoardRowPresentation`** — calculado no mapper backend:
+
+```csharp
+public record BoardRowPresentation(
+    string StatusDisplay,
+    bool IsPastDue,
+    string? WorkOrderTypeDisplay
+);
+```
+
+Mapper: `IWorkOrderBoardMapper` centraliza Past Due e type display.
+
+### 4. Query EF (Fase 1)
+
+- Filtro base: `istemplate != true`
+- Janela: `ScheduledDate >= from && ScheduledDate < to.AddDays(1)`
+- Includes: `Locations`, `AssignToUser`, `Dispatches` → `Vendor` (1 vendor por WO — first active dispatch)
+- POC: `WorkOrderContacts` (primary)
+- Service type: `Trade` ou category join (mínimo: `Trade`)
+- **Não incluir** subquery `lastUpdated` (Comments/AuditLog)
+
+### 5. Search (conforme spike)
+
+- Search scoped à janela temporal
+- Servidor: `StartsWith` em `InternalWONumber`, `SiteCode`
+- Count ≤ **300**: retornar semana inteira; FE filtra title/location/serviceType
+- Count > 300: exigir termo indexável ou retornar 400
+- Assignee: `assigneeId[]` multi — **não** filtrar por nome
+
+Índices (migration separada pós-aprovação):
+
+- `IX_workOrders_ScheduledDate` (P1)
+- `IX_workOrders_InternalWONumber`, `IX_workOrders_SiteCode` (P2, após fix tamanho coluna)
+
+### 6. WorkOrderType
+
+- Mapear coluna legada `WorkOrderType varchar(50)` na entidade EF
+- Expor em `WorkOrderBoardRowDto`
+- `IsPastDue` em presentation — **não** confundir com tipo
+- Enum C# adiado até amostragem prod
+
+### 7. Status mapping
+
+- API retorna status **canônico** (`Open`, `InProgress`, `Completed`, `Cancelled`, `OnHold`)
+- `StatusDisplay` via `IWorkOrderStatusMapper` (workshop G2 separado)
+- Sem migration de enum DB
+
+---
+
+## Consequências
+
+### Positivas
+
+- 1 HTTP call por mudança de semana (FE)
+- Contrato estável para board sem acoplar CRUD legado
+- Performance previsível (janela + threshold 300)
+- Blazor legado inalterado (EF local)
+
+### Negativas / trade-offs
+
+- Duplicação parcial de lógica de listagem vs `GetWorkOrderList` (aceitável — bounded contexts distintos)
+- Vendor technician pode ser null Fase 1 se dispatch spike incompleto
+- Setup DB local necessário para validação integrada
+
+---
+
+## Compliance com spikes
+
+| Spike | Gate | Resultado |
+|-------|------|-----------|
+| Consumer Audit | G0 | `GetWorkOrderList` órfão no repo — endpoint dedicado aprovado |
+| WorkOrderType | G1 | Mapear coluna EF; Overdue = presentation |
+| Search Strategy | G3 | Window-first, threshold 300, StartsWith identificadores |
+
+---
+
+## Fora de escopo Fase 1
+
+- PATCH inline edit
+- Completion doc, media, flags, reorder
+- Search vendor/tech server-side
+- Paginação cross-week
+- Alteração de `GetWorkOrderList`
+
+---
+
+## Próximos passos (implementação)
+
+1. Aprovação explícita **Fase 1 only**
+2. Migration: `WorkOrderType` + índice `ScheduledDate`
+3. `GetWorkOrdersBoard` em `WorkOrderController` + `WorkOrderDataService`
+4. DTOs + `IWorkOrderBoardMapper`
+5. FE: `useWorkOrdersBoard({ from, to })` substituindo `RAW_ORDERS`
+
+---
+
+## Referências
+
+- Gap analysis v3: `work_orders_api_gap_analysis_ce735946.plan.md`
+- [`WorkOrderController.cs`](../../Api.SeaHavenIndustries/Controllers/WorkOrderController.cs)
+- [`WorkOrderDataService.cs`](../../SeaHaven.DataServices/Implementation/WorkOrderDataService.cs)
+- [`DispatchController.List`](../../Api.SeaHavenIndustries/Controllers/DispatchController.cs) — padrão janela temporal
diff --git a/docs/auditoria-work-orders-api-vs-frontend.md b/docs/auditoria-work-orders-api-vs-frontend.md
new file mode 100644
index 0000000..b8a0ce6
--- /dev/null
+++ b/docs/auditoria-work-orders-api-vs-frontend.md
@@ -0,0 +1,299 @@
+# Auditoria — API Work Orders vs Frontend (WorkOrders.tsx)
+
+**Data:** 2026-06-19  
+**Fonte da verdade (FE):** `seahaven.desing/src/pages/WorkOrders.tsx`  
+**Backend auditado:** `seaheven.api`
+
+---
+
+## Resumo executivo
+
+| Métrica | Valor |
+|---------|-------|
+| Compatibility Score | **24/100** |
+| Backend Readiness | **Not Ready** |
+| Confidence | **High** |
+
+A API atual foi construída para **CRUD legado** (listagem paginada, detalhe rico, dispatch). O frontend `WorkOrders.tsx` define um **Schedule Board operacional** (visão semanal, 14 colunas, edição inline, advanced search, completion doc WO-level). Os contratos são fundamentalmente diferentes.
+
+**O que funciona hoje:** id, dueDate, location (parcial), CRUD básico, detalhe rico, comments, audit field-based, mídia WO-level, reatribuição, dispatch.
+
+**O que falta:** listagem window-based, 14 colunas board, PATCH inline, campos derivados, advanced search, completion doc WO-level, jobs Past Due/Carried Over, status 10 labels, WO# 11 dígitos.
+
+---
+
+## Endpoints que existem hoje
+
+| Endpoint | O que entrega |
+|----------|----------------|
+| `GET GetWorkOrderList` | Lista **paginada** (default 12): id, número, título, location, priority, status, dueDate, assignedTo, lastUpdated |
+| `GET Getworkorders` / `GetworkordersDD` | Lista legada para admin/dropdown |
+| `GET GetFilteredWorkorder` / `2` | Filtros legados (assignee, location, priority, status, due date buckets) — carrega tudo em memória |
+| `GET GetWorkorderById` / `{id}` | Detalhe: título, descrição, datas, status, problem, trade, POC, attachments, comments, audit, dispatches |
+| `POST AddWorkorder` | Criação via form: título, descrição, assignee, dueDate, location, priority, mídia, contacts/categories |
+| `POST/PUT EditWorkorder` | Update parcial via form (subset mapeado ao service) |
+| `POST ChangeStatus` | Muda status (string livre) + audit |
+| `POST ChangeAssignment` | Reatribui dispatcher + audit |
+| `POST AddComment` / `AddCommentJson` | Comentário + upload opcional |
+| `GET GetComments` / `GetCommentsByWorkorderId` | Lista comentários |
+| `DELETE DeleteWorkorder` | **Delete físico** (não soft cancel) |
+| Dispatch endpoints | Vendor, checklist, signoff, verify — **nível dispatch**, não board |
+
+**Lookups relacionados (outros controllers):** `Common/GetUsers`, `Location/GetLocationList`, `Vendor/GetVendorList` — paginados, contrato diferente do FE.
+
+**Documentado mas não implementado no código:** `GET GetWorkOrdersBoard`, `IWorkOrderBoardMapper`, `IWorkOrderStatusMapper` (ver `docs/adr/work-orders-board-api.md`).
+
+---
+
+## 1. Listagem da tela principal (visão semanal)
+
+| Frontend espera | API entrega hoje | Gap |
+|-----------------|------------------|-----|
+| 1 call por semana (`weekStart` / `weekEnd`) | Paginação `page` / `pageSize` sem janela temporal | Sem fetch window-based |
+| WOs agrupados por dia (Mon–Fri) | Lista flat paginada | Sem `scheduledDate` na projeção de listagem |
+| Seção **Unscheduled** sempre visível no topo | Só WOs da página atual | Sem WOs sem data retornados independente da semana |
+| `targetWeek` (scheduling week-only) | Campo inexistente na entidade/API | Não implementado |
+| Contador `X of Y` da semana ativa | `totalCount` global paginado | Contagem inadequada para o board |
+| Skeleton Mon–Fri vazios | N/A (FE-only) | OK — responsabilidade do FE |
+
+**Evidência BE:** `WorkOrderDataService.GetWorkOrderListPagedAsync` — projeção L163-183, sem `ScheduledDate`, `SiteCode`, vendor, type.
+
+---
+
+## 2. Colunas da tabela (`COLS`)
+
+Definidas no FE em `WorkOrders.tsx` L4234-4249.
+
+| Coluna FE | Campo(s) FE | API hoje | Gap |
+|-----------|-------------|----------|-----|
+| Grip | drag reorder | Ausente | FE local-only; BE não persiste ordem |
+| Flag | flag pessoal | Ausente | FE session-only |
+| **SITE** | `site`, `pocName`, `pocPhone`, `pocNotes` | List: `location` (name); Detail: POC via `WorkOrderContacts` | Sem `siteCode` na listagem; sem POC na lista |
+| **WO** | `woNumber`, `rescheduleCount`, `carriedOver` | `internalWONumber` / `workerOrderNumber` | Formato ≠ 11 dígitos; sem badges ↻ ↷N |
+| **TYPE OF WO** | `type` (PM / Reactive / Emergency / Add-On / Overdue) | Não exposto (`WorkOrderType` em `db.txt`, não mapeado em EF) | Coluna inoperante |
+| **ASSIGNED TO** | `dispatcherId` + avatar/cor | `assignedTo` (nome completo); `AssignTo` = GUID Identity | Sem id/initials/color para avatar |
+| **SCHEDULE ON** | `scheduledOn`, `targetWeek` | Detail: `scheduledDate`; **list: ausente** | Listagem sem data de agendamento |
+| **DUE DATE** | `dueDate` | `dueDate` | **OK** na listagem |
+| **SERVICE** | `pm` | Detail: `trade` / `problem`; list: ausente | Coluna vazia na lista |
+| **VENDOR** | `company`, `tech`, `techPhone` | Detail: `dispatches` → vendor; list: ausente | Coluna vazia na lista |
+| **APPT TIME** | `apptTime` (ex: "07:00 – 09:00") | Entidade: `ScheduledStart`; sem `ScheduledEnd` | Janela de horário incompleta |
+| **STATUS** | 10 labels + overlay Past Due | String legada DB + enum 5 valores API | Sem mapping para status operacionais do FE |
+| **COMP DOC** | `docStatus` (Yes / No / NN) | Ausente no WO | Completion existe só no **dispatch** (`VerifyDispatch`) |
+| Actions | View / Edit | `GetWorkorderById` separado | Detalhe existe; contrato diferente |
+
+---
+
+## 3. Filtros e busca
+
+### Barra principal (FE L5083-5099)
+
+| Frontend | API hoje | Gap |
+|----------|----------|-----|
+| **Dispatcher** multi-select + `__unassigned__` + default usuário logado | `assignee` single string; `__unassigned` suportado em `GetWorkOrderList` | Multi-select e default "My WOs" não cobertos |
+| **Semana ativa** | Sem filtro `ScheduledDate` | Filtro semanal inexistente |
+| **Tipo** (All / PM / Reactive / Emergency / Add-On / Overdue) | Sem filtro por work order type | Inexistente |
+| **Busca contextual** na semana (site, wo#, dispatcher, location, pm, company, tech, status) | Search em 5 campos (`InternalWONumber`, `WorkerOrderNumber`, `Title`, `Location`), escopo global paginado | Campos e escopo incompatíveis |
+
+### Advanced Search (FE L4255-4324)
+
+| Frontend | API hoje | Gap |
+|----------|----------|-----|
+| Lista plana cross-week | Ausente | Sem endpoint dedicado |
+| Date range (this-week, last-week, this-month, last-3-months, next-week, next-month, custom) | `GetFilteredWorkorder` com due date buckets legados | Semântica diferente |
+| Filtros: sites[], types[], dispatchers[], statuses[], pmTypes[], vendorTechs[], docs[] | Parcial em endpoints legados | Cobertura incompleta |
+
+---
+
+## 4. Edição inline (spreadsheet-style)
+
+| Frontend | API hoje | Gap |
+|----------|----------|-----|
+| PATCH por campo (site, wo#, type, dispatcher, schedule, due, service, vendor, appt, status…) | `EditWorkorder` (form multipart) + `ChangeStatus` + `ChangeAssignment` separados | Sem update granular por campo |
+| Auto-schedule: `Incomplete` → `Scheduled` quando data + dispatcher | Ausente no BE | Regra `maybeAutoSchedule` só no FE |
+| `rescheduleCount++` ao mudar `scheduledOn` | Campo inexistente | Badge ↻ impossível |
+| Limpar `isPastDue` ao reagendar para data futura | Campo derivado inexistente | Past Due não limpa via API |
+| Bloquear mudança de status se `isPastDue` | `ChangeStatus` aceita qualquer string | Sem validação 422 |
+| WO# único 11 dígitos normalizado | Gerador `WO-{yyyyMMdd}-{random}` ou sync sequencial `10000001` | Formato e unicidade incompatíveis |
+| WO cancelado read-only | Sem enforcement no BE | Só lógica no FE (`WOSlideOver` L2380) |
+
+**Evidência BE:** `WorkOrderController.Editworkorder` L182-192 mapeia subset para `UpdateWorkOrderDTO` — ignora `Problem`, `Trade`, `ScheduledDate`, `Source` apesar de existirem em `EditWorkorder_DTO`.
+
+---
+
+## 5. Criação de WO
+
+| Frontend | API hoje | Gap |
+|----------|----------|-----|
+| Wizard `NewWOWizard` + inline `InlineRow` | `POST AddWorkorder` | Campos do wizard majoritariamente ausentes |
+| Campos: site, type, scheduledOn, targetWeek, pm, company, tech, appt, POC | `CreateWorkOrderDTO`: title, description, assignTo, dueDate, location | Contrato incompleto |
+| Status inicial `Incomplete` | Cria com `WorkOrderStatus.Open` | Status inicial diferente |
+| `scheduleWeekOnly` / `targetWeek` | Ausente | Week-only scheduling impossível |
+| Navegação automática para semana do WO criado | Depende de listagem semanal | Listagem incompatível |
+
+---
+
+## 6. Cancelamento
+
+| Frontend | API hoje | Gap |
+|----------|----------|-----|
+| Soft cancel → status `Canceled` | `POST ChangeStatus(id, "Canceled")` manual | Sem endpoint `POST cancel` dedicado |
+| WO cancelado não editável | Sem bloqueio no BE | Enforcement só no FE |
+| Delete permanente (Admin) | `DELETE DeleteWorkorder` — delete físico | Comportamento diverge do soft cancel FE |
+
+---
+
+## 7. Slide-over (`WOSlideOver`)
+
+| Tab FE | API hoje | Gap |
+|--------|----------|-----|
+| **Info** | `GET GetWorkorderById` | Omite `siteCode`; sem campos derivados FE (`isPastDue`, `rescheduleCount`, etc.) |
+| **Comments** | `AddComment` + `GetCommentsByWorkorderId` | Formato FE `{authorId, text, time}` vs BE `{Commenttext, FirstName, Documents}` |
+| **Audit Log** | `WorkOrderAuditLog` retornado no detalhe | Schema `{fieldName, oldValue, newValue, action}` vs FE `{type: manual\|system, dispatcherId?, action, time}` |
+| **Completion Doc** | `SignOffName` / `SignOffAttachment` no WO; `VerifyDispatch` no dispatch | Sem template por service type, PDF, `docStatus` WO-level |
+| **Extra Docs / Media** | `BeforPhoto`, `AfterPhoto`, `workOrderAttachments` | Sem `MediaFile.category`; sem API extra docs dedicada |
+
+---
+
+## 8. Regras de sistema (background jobs)
+
+| Frontend assume | API hoje | Gap |
+|-----------------|----------|-----|
+| Job Past Due: `scheduledOn < hoje` + não terminal → `isPastDue=true` | Ausente (zero `BackgroundService` / Hangfire / Quartz no repo) | Flag nunca setada automaticamente |
+| Job Carried Over: virada de semana → `carriedOver++` | Ausente | Contador ↷N nunca incrementado |
+| Type Overdue promotion | Ausente | Filtro/tipo Overdue não automático |
+| Sync APM | `SyncController` POST manual (DynamoDB → SQL) | On-demand, não integrado à UX do board |
+
+---
+
+## 9. Lookups (catálogos)
+
+| FE usa (mock estático) | API relacionada | Gap |
+|------------------------|-----------------|-----|
+| `DISPATCHERS` (id, name, initials, color) | `Common/GetUsers` | Sem initials/color; paginado; ids são GUIDs |
+| `SITE_OPTIONS` (code → city, state) | `Location/GetLocationList` | Sem lookup por site code; sem mapeamento BK5 → Dallas |
+| `PM_TYPES` | Ausente | Sem catálogo de service types |
+| `TECHNICIANS` (name, company, phone) | `Vendor/GetVendorList` | Sem endpoint technicians |
+| `WEEK_RANGES` (Mon–Fri + flag LIVE) | Ausente | Sem endpoint weeks |
+
+---
+
+## Contrato de dados — campo a campo
+
+| Campo FE (`WorkOrder`) | Campo BE | Status |
+|------------------------|----------|--------|
+| `id` | `WorkOrder.Id` | SUPPORTED |
+| `woNumber` | `InternalWONumber` / `WorkerOrderNumber` | PARTIALLY_SUPPORTED — formatos conflitantes |
+| `site` | `SiteCode` | PARTIALLY_SUPPORTED — entidade tem; API omite na listagem |
+| `type` | — (`WorkOrderType` só em SQL) | NOT_SUPPORTED |
+| `dispatcherId` | `AssignTo` (GUID) | PARTIALLY_SUPPORTED |
+| `scheduledOn` | `ScheduledDate` | PARTIALLY_SUPPORTED — list omite |
+| `dayGroup` / `dayLabel` | — | NOT_SUPPORTED (derivado) |
+| `location` | `Locations.Name` | SUPPORTED (via join) |
+| `pm` | `Trade` / `Problem` | PARTIALLY_SUPPORTED |
+| `company` / `tech` | `Dispatches` → `Vendor` | PARTIALLY_SUPPORTED — não inline na lista |
+| `techPhone` | — | NOT_SUPPORTED |
+| `apptTime` | `ScheduledStart` (sem end) | PARTIALLY_SUPPORTED |
+| `status` | `Status` (string livre) | PARTIALLY_SUPPORTED — 10 vs 5+ formatos |
+| `docStatus` | — | NOT_SUPPORTED |
+| `pocName` / `pocPhone` / `pocNotes` | `WorkOrderContacts` | PARTIALLY_SUPPORTED — notes ausente |
+| `dueDate` | `DueDate` | SUPPORTED |
+| `rescheduleCount` | — | NOT_SUPPORTED |
+| `carriedOver` | — | NOT_SUPPORTED |
+| `originalWeek` / `originalDate` | — | NOT_SUPPORTED |
+| `isPastDue` | — | NOT_SUPPORTED (derivado) |
+| `targetWeek` | — | NOT_SUPPORTED |
+
+---
+
+## Regras de negócio — FE vs BE
+
+| Regra FE | Evidência FE | BE hoje | Status |
+|----------|--------------|---------|--------|
+| Auto-schedule Incomplete → Scheduled | `maybeAutoSchedule` L500-506 | Ausente | NOT_SUPPORTED |
+| Reschedule incrementa contador | `updateScheduledOn` L4856 | Ausente | NOT_SUPPORTED |
+| Reschedule limpa Past Due | L4851-4857 | Ausente | NOT_SUPPORTED |
+| Status bloqueado em Past Due | `StatusCell` L1120-1159 | `ChangeStatus` sem validação | NOT_SUPPORTED |
+| WO# único 11 dígitos | `findDuplicateWONumber` L4897 | Gerador random; `InternalNumberExistsAsync` sem normalização | NOT_SUPPORTED |
+| Cancel → Canceled, read-only | `cancelWO` L4946; `WOSlideOver` L2380 | `ChangeStatus` manual | PARTIALLY_SUPPORTED |
+| Carried over job semanal | Audit derivado L2414-2416 | Sem job | NOT_SUPPORTED |
+| Completion doc por tipo de serviço | `CompDocDialog` L3902+ | Dispatch verify only | NOT_SUPPORTED (WO-level) |
+| Emergency/Reactive → media flow | `isMediaWO` L332-334 | Mídia WO genérica | PARTIALLY_SUPPORTED |
+
+---
+
+## Diagrama — contrato atual vs esperado
+
+```
+HOJE (GetWorkOrderList)              FRONTEND (WorkOrders.tsx)
+─────────────────────                ─────────────────────────
+Paginação 12/page                    1 call = semana inteira
+Sem ScheduledDate                    Agrupamento Mon–Fri
+Sem siteCode, type, vendor           14 colunas preenchidas
+Sem unscheduled semantics            Seção Unscheduled fixa
+5 status legados                     10 status + Past Due overlay
+CRUD admin                           Schedule Board operacional
+EditWorkorder (form)                 PATCH inline por célula
+```
+
+---
+
+## Cobertura por área
+
+| Área | Cobertura estimada |
+|------|-------------------|
+| Listagem board (visão semanal) | ~5% |
+| Colunas da tabela (14) | ~15% |
+| Filtros e busca | ~10% |
+| Edição inline | ~0% |
+| Criação (wizard/inline) | ~25% |
+| Slide-over (detalhe) | ~40% |
+| Completion doc WO-level | ~0% |
+| Background jobs | ~0% |
+| Lookups/catálogos | ~20% |
+
+---
+
+## Critical blockers
+
+1. **Sem API window-based** para visão semanal + Unscheduled — tela principal não carrega.
+2. **Contrato de listagem incompatível** com 14 colunas do board.
+3. **Campos persistidos ausentes** — `rescheduleCount`, `carriedOver`, `targetWeek`, `docStatus`, `isPastDue`.
+4. **Sem PATCH inline** — edição spreadsheet-style impossível.
+5. **Advanced search cross-week inexistente.**
+6. **Status 10 valores + Past Due** sem mapping layer implementado.
+7. **Completion doc WO-level inexistente** — coluna COMP DOC inoperante.
+8. **WO# 11 dígitos único** não suportado.
+9. **Jobs Past Due / Carried Over ausentes.**
+
+---
+
+## Non-critical gaps
+
+- Reorder intra-dia persistido (FE já local-only)
+- Flags pessoais (FE session-only)
+- Paginação 12/24/48/96 (FE não implementou)
+- Bulk select (FE não implementou)
+- `[Authorize]` comentado no `WorkOrderController` (risco de segurança)
+
+---
+
+## Referências
+
+- Frontend: `seahaven.desing/src/pages/WorkOrders.tsx`
+- Controller: `Api.SeaHavenIndustries/Controllers/WorkOrderController.cs`
+- Data service: `SeaHaven.DataServices/Implementation/WorkOrderDataService.cs`
+- Entidade: `Data.SeaHavenIndustries/Models/WorkerOrder.cs`
+- ADR (proposto, não implementado): `docs/adr/work-orders-board-api.md`
+- Spikes: `docs/spikes/consumer-audit-getworkorderlist.md`, `search-strategy.md`, `status-mapping.md`, `work-order-type.md`
+
+---
+
+## Classificação final
+
+| Métrica | Valor |
+|---------|-------|
+| Compatibility Level | **Minimally Compatible** |
+| Backend Readiness | **Not Ready** |
+| Confidence | **High** |
+
+Este documento reporta apenas **findings** — gaps entre o que a API entrega hoje e o que o frontend especifica. Não inclui propostas de implementação.
diff --git a/docs/roadmap-work-orders-board.md b/docs/roadmap-work-orders-board.md
new file mode 100644
index 0000000..4af57f4
--- /dev/null
+++ b/docs/roadmap-work-orders-board.md
@@ -0,0 +1,907 @@
+# Roadmap de Implementação — Work Orders API vs Frontend Board
+
+**Documento:** Relatório consolidado de arquitetura e entrega  
+**Fonte da verdade (frontend):** `seahaven.desing/src/pages/WorkOrders.tsx`  
+**Backend:** `seaheven.api`  
+**Auditoria base:** [auditoria-work-orders-api-vs-frontend.md](auditoria-work-orders-api-vs-frontend.md)  
+**Estado atual:** Compatibility Score **24/100** — backend **Not Ready**  
+**Nota técnica do programa:** **9.0/10** (meta kickoff enterprise **9.5+**)  
+**Escopo:** capacidades de negócio, domínio, governança, fases, riscos e validação — sem design de API, schema ou código
+
+---
+
+## 1. Executive Summary
+
+### 1.1 Readiness geral
+
+O backend é **maduro para CRUD legado, dispatch, vendor portal, checklist/sign-off e audit**, mas foi construído para **listagem paginada administrativa**, não para o **Schedule Board operacional** que o frontend define. A tela principal do board **não pode funcionar** com os contratos atuais.
+
+| Dimensão | Avaliação |
+|----------|-----------|
+| Tela principal (visão semanal) | ~5% |
+| 14 colunas do board | ~15% |
+| Edição inline | ~0% |
+| Completion doc WO-level | ~0% |
+| Background jobs | ~0% |
+| Detalhe / slide-over | ~40% |
+| **Média ponderada** | **~24%** |
+
+### 1.2 Problemas arquiteturais principais
+
+1. **Paradigma de contrato incompatível** — paginação global vs. janela semanal com seção Unscheduled fixa.
+2. **Projeção de listagem insuficiente** — 9 das 14 colunas do board não são alimentadas pela listagem atual.
+3. **Ausência de camada de domínio operacional** — campos derivados, tipo de WO e status operacionais ausentes ou não expostos.
+4. **Database drift** — `WorkOrderType` existe no SQL legado mas não no EF; possíveis outras colunas desalinhadas.
+5. **Modelo de mutação inadequado** — form multipart vs. edição granular por célula.
+6. **Sem automação de sistema** — zero infraestrutura de jobs; regras do FE nunca executam no servidor.
+7. **Cinco consumidores paralelos** — SHOC, Blazor EF, Vendor Portal, Sync/Lambda, e-mails — sem governança de ownership.
+8. **Duas trilhas paralelas** — Blazor acessa EF direto; API REST é integração do SHOC.
+
+### 1.3 Maior risco do programa
+
+**Governança de ownership de dados** — quem pode alterar cada campo entre SHOC, Vendor Portal, Sync, Blazor e Jobs. A arquitetura de domínio resolve fontes da verdade; a governança operacional é o gate final.
+
+### 1.4 Decisões de produto registradas
+
+- **Novas funcionalidades do board** → somente via API REST para o frontend React (SHOC).
+- **Blazor (`SeaHavenIndustries`)** → não recebe board, inline edit, jobs, advanced search nem completion doc WO-level; manutenção mínima até sunset do módulo WO.
+- **Vendor Portal** → permanece ativo; não-regressão obrigatória.
+- **DynamoDB/Sync** → ponte temporária; aposentar após SHOC ingerir direto ([TODO.md](../TODO.md)).
+
+### 1.5 Complexidade e esforço
+
+| Métrica | Valor |
+|---------|-------|
+| Complexidade geral | **Alta** |
+| Esforço total | **XL** (6–9 meses, 2 squads; ou 4–6 meses, 3 squads) |
+| Fase 0 — Fundação domínio + governança | L |
+| Fase 1 — Board semanal | L |
+| Fase 2 — Edição inline + concorrência | L |
+| Fase 3 — Criação e cancelamento | M |
+| Fase 4 — Busca avançada | M |
+| Fase 5 — Domain events (jobs) | M |
+| Fase 6 — Completion doc e slide-over | M |
+| Fase 7 — Rollout e produção | M |
+
+### 1.6 Gates bloqueantes da Fase 0
+
+Nenhuma implementação de board inicia sem:
+
+1. Domain Architecture Review (DAR) aprovado
+2. **Data Ownership Model** assinado
+3. **Field Ownership Matrix** assinada
+4. **Audit Event Contract** aprovado
+5. Volume Discovery Report (sem premissa de volume)
+6. Database drift report (SQL vs EF)
+7. Spike vendor/dispatch
+8. Data migration dry-run
+9. RowVersion multi-agregado definido
+
+---
+
+## 2. Capability Gap Assessment
+
+### 2.1 Weekly Scheduling Board — **Critical**
+- **Atual:** paginação sem janela temporal, sem Unscheduled.
+- **Desejado:** 1 call/semana, Mon–Fri + Unscheduled, contador `X of Y`.
+
+### 2.2 Work Order Lifecycle — **High**
+- **Atual:** form parcial, status `Open`, delete físico.
+- **Desejado:** wizard/inline completo, `Incomplete`, soft cancel read-only.
+
+### 2.3 Inline Editing — **Critical**
+- **Atual:** `EditWorkorder` multipart; endpoints separados.
+- **Desejado:** update granular por célula com regras embutidas.
+
+### 2.4 Search & Filtering — **High**
+- **Atual:** 5 campos, escopo global, assignee single-select.
+- **Desejado:** busca contextual na semana + advanced search cross-week.
+
+### 2.5 Status Management — **Critical**
+- **Atual:** enum 5 valores + string livre; sem Past Due.
+- **Desejado:** 10 labels + flag Past Due separada; auto-schedule; bloqueios.
+
+### 2.6 Completion Documentation — **High**
+- **Atual:** sign-off básico; verify só no dispatch.
+- **Desejado:** `docStatus` WO-level (Yes/No/NN); templates por serviço.
+
+### 2.7 Vendor Management (board) — **High**
+- **Atual:** vendor só no detalhe via dispatch.
+- **Desejado:** colunas VENDOR/APPT na lista; edição via dispatch primário.
+
+### 2.8 Scheduling Intelligence — **Critical**
+- **Atual:** `ScheduledDate` no detalhe; sem `targetWeek`, `ScheduledEnd`.
+- **Desejado:** agendamento semântico completo; badges ↻ e ↷N.
+
+### 2.9 Audit & Tracking — **Medium**
+- **Atual:** audit field-based legado.
+- **Desejado:** `{type: manual|system, dispatcherId?, action, time}` + eventos de sistema.
+
+### 2.10 Background Automation — **Critical** (como otimização, não fonte da verdade)
+- **Atual:** zero jobs.
+- **Desejado:** WeekRolled, cache opcional PastDue; domínio recalcula on-read.
+
+### 2.11 Lookup Data — **High**
+- **Atual:** lookups paginados incompatíveis; sem PM types, technicians.
+- **Desejado:** dispatchers (initials/color), sites por code, PM types, technicians.
+
+### 2.12 Reporting / Contadores — **Medium**
+- **Atual:** `totalCount` global.
+- **Desejado:** `X of Y` semanal.
+
+### 2.13 Security — **High**
+- **Atual:** `[Authorize]` comentado no `WorkOrderController`.
+- **Desejado:** auth ativa; default "My WOs".
+
+---
+
+## 3. Dependency Map
+
+```mermaid
+flowchart TD
+    subgraph phase0 [Fase0_Fundacao]
+        DAR[DAR e 3 artefatos]
+        DOM[Agregados dominio]
+        VOL[Volume Discovery]
+        OWN[Data Ownership]
+    end
+    subgraph phase1 [Fase1_Board]
+        B1[Listagem semanal]
+        B2[14 colunas]
+    end
+    subgraph phase2 [Fase2_Mutacao]
+        M1[Inline edit]
+        M2[Concorrencia]
+    end
+    subgraph phase3 [Fase3_Lifecycle]
+        L1[Criacao wizard]
+        L2[Cancelamento]
+    end
+    subgraph phase45 [Fase4_5]
+        S1[Search]
+        E1[Domain events]
+    end
+    subgraph phase6 [Fase6_Completion]
+        C1[DocStatus slideover]
+    end
+    DAR --> DOM
+    DOM --> B1
+    OWN --> M1
+    VOL --> B1
+    B1 --> B2 --> M1
+    M1 --> L1
+    B2 --> S1
+    DOM --> E1
+    B2 --> C1
+```
+
+**Ordem obrigatória:** Fase 0 → Board → Inline → Lifecycle → Search/Events → Completion → Rollout.
+
+---
+
+## 4. Domain Model
+
+### 4.1 Agregados e limites (anti God Entity)
+
+```mermaid
+flowchart TB
+    subgraph root [Aggregate Root WorkOrder]
+        CORE[Core Lifecycle Assignment]
+        SCH[Scheduling slice]
+        TRK[Tracking slice]
+        COMP[Completion slice]
+        ANA[Analytics slice]
+    end
+    subgraph separate [Agregado separado]
+        DISP[Dispatch fonte vendor]
+    end
+    AUD[WorkOrderAuditLog append-only]
+    CORE --> SCH
+    CORE --> TRK
+    CORE --> ANA
+    CORE --> COMP
+    CORE --> DISP
+    CORE --> AUD
+```
+
+| Agregado | Responsabilidade |
+|----------|------------------|
+| **WorkOrder (core)** | Id, WoNumber, Type, LifecycleStatus, SiteCode, LocationId, DueDate, AssignTo, Title, RowVersion |
+| **Scheduling slice** | ScheduledDate, ScheduledStart/End, TargetWeek, ScheduleWeekOnly |
+| **Tracking slice** | OriginalWeek, OriginalDate (set-once) |
+| **Analytics slice** | RescheduleCount, CarriedOver (contadores históricos) |
+| **Completion slice** | DocStatus, refs attachments |
+| **Dispatch** | Vendor, tech, status portal — **fonte da verdade vendor** |
+| **Audit** | Rastreabilidade imutável |
+
+**Proibido:** `VendorId`, `TechName`, `TechPhone` canônicos na WO.
+
+### 4.2 Scheduling Aggregate Growth Watchlist
+
+Campos que **não** entram em Scheduling sem ARB review: `MoveReason`, `MoveUser`, `MoveCategory`, `MoveSource`. Metadados de movimentação → Audit. Gate: slice Scheduling > 8 campos operacionais → ARB obrigatório.
+
+### 4.3 Campos reaproveitados (sem nova coluna)
+
+`SiteCode`, `ScheduledDate`, `DueDate`, `AssignTo`, `Trade`/`Problem`, `LocationId`, POC via `WorkOrderContacts`.
+
+### 4.4 Database drift conhecido
+
+| Coluna SQL | Ação |
+|------------|------|
+| `WorkOrderType` | Mapear no Core |
+| `AvettaTask` | Inventariar; mapear ou deprecar |
+| `AssignDate` | Inventariar; mapear ou deprecar |
+
+Gate Fase 0: diff completo SQL vs `ApplicationDbContextModelSnapshot`.
+
+### 4.5 Entidades relacionadas
+
+| Entidade | Mudança | Fase |
+|----------|---------|------|
+| `WorkOrderContacts` | `Notes` (pocNotes) | 0 |
+| `WorkOrderAuditLog` | EventType Manual/System/Vendor/Sync | 0 |
+| `ApplicationUser` | Initials, Color | 0–1 |
+| `Locations` | SiteCode | 0–1 |
+| `WorkOrderAttachments` | Category | 2–6 |
+| `WorkOrderEnums` | LifecycleStatus, WorkOrderType, DocStatus, OperationalFlags | 0 |
+| `Dispatch` | Proteção regression | contínuo |
+
+Fora de escopo imediato: `FollowUps`, `Quotes`, `PMSchedules`, `Employee`, `WorkOrderCategories` no board.
+
+---
+
+## 5. Domain Architecture Review (DAR)
+
+### 5.1 Fonte da verdade por conceito
+
+| Conceito | Fonte da verdade | Proibido |
+|----------|------------------|----------|
+| Status | `LifecycleStatus` (10 valores) | String livre; status composto |
+| Past Due | `OperationalFlags.PastDue` | Misturar no enum lifecycle |
+| Vendor/Tech | Dispatch primário | Duplicar na WO |
+| Schedule | Scheduling slice | Duplicar no core |
+| Completion | Completion.DocStatus | Só inferir de dispatch |
+| Reschedule/Carried | Analytics + audit | Job blind overwrite |
+| WO# | Campo canônico único | Dois números sem regra |
+| POC | WorkOrderContacts | Só no detalhe |
+
+### 5.2 Matriz Persistido vs Derivado
+
+| Campo FE | Persistido | Derivado | Fonte / Regra |
+|----------|------------|----------|---------------|
+| `lifecycleStatus` | Sim | Não | Core |
+| `isPastDue` | Não | **Sim** | `ScheduledDate < hoje` AND NOT terminal; job = cache opcional |
+| `type` Overdue | Não | **Sim** | Regra type + schedule + status |
+| `carriedOver` | Sim | Não | Métrica histórica; incremento via `WeekRolled` |
+| `rescheduleCount` | Sim | Parcial | Domain event em mudança de `ScheduledDate` |
+| `docStatus` | Sim | Não | Completion slice |
+| `dayGroup`, `apptTime` | Não | Sim | Calculados na leitura |
+| vendor/tech | Via Dispatch | Projeção | Join dispatch primário |
+
+**Regra de ouro:** Jobs nunca são a única fonte da verdade. Leitura sempre recalcula derivados.
+
+### 5.3 Lifecycle Status vs Operational Flags
+
+```text
+LifecycleStatus  → enum único (10 valores FE)
+OperationalFlags → PastDue, (futuro: Escalated)
+```
+
+Filtro status = LifecycleStatus. Overlay Past Due = flag. Bloqueio de edição = validação sobre flag.
+
+### 5.4 CarriedOver — justificativa
+
+| | `isPastDue` | `carriedOver` |
+|--|-------------|---------------|
+| Natureza | Estado pontual | **Métrica histórica acumulada** |
+| Persistir | Não (derivado) | **Sim** (contador) |
+| Por quê | Calculável da data atual | Não recuperável só do schedule atual |
+
+Invariante: incremento **somente** via domain event `WeekRolled`.
+
+### 5.5 Vendor / Dispatch — spike obrigatório (Fase 0)
+
+1. WO mantém `PrimaryDispatchId`
+2. Colunas VENDOR = projeção do dispatch primário
+3. Edição inline vendor = mutação no Dispatch
+4. WO sem dispatch → edição cria dispatch primário
+
+Entregável: ADR "Vendor Source of Truth". Critério: zero `Tech*` canônicos na WO.
+
+### 5.6 Jobs — domínio primeiro
+
+| Job | Papel |
+|-----|-------|
+| Past Due diário | Cache refresh opcional; on-read sempre correto |
+| Carried Over semanal | Dispara `WeekRolled` → incrementa contador + audit system |
+| Promoção Overdue | Derivado on-read |
+| Audit | Síncrono em toda mutação desde Fase 0 |
+
+### 5.7 Database drift investigation
+
+Diff SQL vs EF; classificar: mapear, deprecar, mover para agregado satélite. Tabelas: `workOrders`, `Comments`, `Locations`, `Dispatch`.
+
+---
+
+## 6. Data Ownership Model
+
+### 6.1 Ownership por ator
+
+| Ator | Pode alterar | Não pode alterar |
+|------|--------------|------------------|
+| **SHOC** | Lifecycle, Schedule, Assignment, Completion, vendor via Dispatch, POC, WO# | Checklist/signoff vendor |
+| **Vendor Portal** | Dispatch status, checklist, signoff, comments | Schedule, lifecycle, assignment, DueDate |
+| **Sync/Lambda** | Campos ingest (Description, ExternalId, etc.) — só owner Sync | Campos SHOC-owned após 1ª edição manual |
+| **Blazor** | Campos legados até sunset | Campos novos board |
+| **Jobs** | Incremento CarriedOver; audit system | Lifecycle, Schedule, Dispatch |
+
+### 6.2 Field Ownership Matrix
+
+| Campo | Agregado | Owner escritor | Sync sobrescreve? | Conflito SHOC vs Sync |
+|-------|----------|----------------|-------------------|----------------------|
+| LifecycleStatus | Core | SHOC | Não após 1ª edição SHOC | SHOC vence |
+| AssignTo | Core | SHOC | Não após 1ª edição SHOC | SHOC vence |
+| ScheduledDate / janela | Scheduling | SHOC | Não | SHOC vence |
+| TargetWeek | Scheduling | SHOC | Não | SHOC vence |
+| DueDate | Core | SHOC + Sync | Sim se nunca editado SHOC | SHOC se ManualEditFlag |
+| Description | Core | SHOC + Sync | Merge / SHOC priority | SHOC se editado |
+| SiteCode / Location | Core | SHOC + Sync | Sim na criação; não após SHOC | SHOC após flag |
+| WorkOrderType | Core | SHOC | Sim na criação ingest | SHOC após flag |
+| WoNumber | Core | SHOC | Não | SHOC only |
+| Vendor / tech | Dispatch | SHOC + Vendor | Não | Domínios separados |
+| Checklist/signoff | Dispatch | Vendor | Não | Vendor vence |
+| DocStatus | Completion | SHOC | Não | SHOC only |
+| RescheduleCount / CarriedOver | Analytics | Domain events | Não | N/A |
+| ExternalWorkOrderId | Core | Sync | Sim (idempotente) | Sync only |
+
+**ManualEditFlag:** primeira edição SHOC marca campo; Sync subsequente skip + audit `SyncRejected`.
+
+### 6.3 Sync merge — cenários
+
+| Cenário | Comportamento |
+|---------|---------------|
+| Sync DueDate + SHOC ScheduledDate | Merge — campos distintos |
+| Sync Status + SHOC Status | SHOC vence; sync skip |
+| Sync AssignTo + SHOC AssignTo | SHOC vence |
+| Sync Description + SHOC Description | SHOC vence se ManualEditFlag |
+| Sync cria WO novo | Full ingest |
+| Sync atualiza por ExternalWorkOrderId | Field-level merge por matriz |
+
+---
+
+## 7. Concurrency Strategy
+
+### 7.1 Atores
+
+Dispatcher (SHOC), Vendor (Portal), Sync/Lambda, Blazor (congelado), Jobs.
+
+### 7.2 RowVersion multi-agregado
+
+| Agregado | RowVersion | Quando muda |
+|----------|------------|-------------|
+| **WorkOrder (root)** | No Core | Mutação Core, Scheduling, Completion, Analytics na mesma transação |
+| **Dispatch** | Próprio | Mutação vendor/tech/checklist/status dispatch |
+| **Projeção board** | N/A | FE envia `workOrderVersion` + `dispatchVersion` |
+
+**Propagação:**
+- SHOC edita ScheduledDate → bump WO.RowVersion
+- SHOC edita vendor → bump Dispatch.RowVersion
+- Vendor edita checklist → bump Dispatch.RowVersion only
+- Sync altera Description → bump WO se merge aplicado
+- DocStatus → bump WO (Completion na mesma transação)
+
+Conflito → 409 com `currentState` para refresh.
+
+### 7.3 Concurrency Ownership Rules
+
+| Cenário | Resultado |
+|---------|-----------|
+| SHOC vs SHOC (mesmo campo) | 409; último RowVersion válido |
+| SHOC vs Sync (mesmo campo) | Vence owner do campo |
+| SHOC vs Sync (campos diferentes) | Merge |
+| Vendor vs Sync | Domínios separados |
+| SHOC vs Vendor | Merge se campos distintos; impossível mesmo conceito por design |
+| Job WeekRolled vs SHOC reschedule | Idempotência WO+semana |
+| Blazor vs SHOC | SHOC vence; Blazor congelado |
+
+### 7.4 Testes
+
+Fase 2: conflito paralelo (2 dispatchers, sync durante edição); dual RowVersion; audit count = fields changed.
+
+---
+
+## 8. Audit Event Contract
+
+### 8.1 Princípios
+
+- Toda mutação gera audit **síncrono** desde Fase 0
+- Edição inline = **1 evento por campo**
+- Audit para investigação operacional, não só compliance
+
+### 8.2 Schema por evento
+
+| Campo | Obrigatório |
+|-------|-------------|
+| WorkOrderId | Sim |
+| EventType | Sim: Manual / System / Sync / Vendor |
+| Action | Sim: FieldChanged, StatusChanged, WeekRolled, SyncRejected |
+| FieldName | Sim para inline |
+| OldValue, NewValue | Sim |
+| ActorId, ActorType | Sim para Manual |
+| Timestamp | Sim UTC |
+| CorrelationId | Recomendado |
+| DispatchId | Quando evento é no dispatch |
+
+### 8.3 Mutação → eventos
+
+| Mutação | Eventos |
+|---------|---------|
+| ChangeStatus | 1× StatusChanged |
+| Inline cell | 1× FieldChanged por campo |
+| Auto-schedule | StatusChanged + FieldChanged se aplicável |
+| Reschedule | FieldChanged + RescheduleCount + audit analytics |
+| WeekRolled | System WeekRolled + CarriedOver old/new |
+| Sync skip | Sync SyncRejected |
+| Vendor checklist | Vendor FieldChanged no Dispatch |
+
+### 8.4 Contrato FE (Audit tab)
+
+`{ type, dispatcherId?, action, fieldName?, oldValue, newValue, time }`
+
+---
+
+## 9. Data Migration Plan
+
+### 9.1 Status
+
+| Legado | LifecycleStatus alvo |
+|--------|------------------------|
+| Open | Incomplete |
+| InProgress | In Progress |
+| Completed | Complete |
+| Cancelled | Canceled |
+| OnHold | On Hold |
+| Desconhecido | Incomplete + NeedsReview |
+
+Processo: dry-run staging; 100% classificados; `LegacyStatus` read-only 1 release; rollback documentado.
+
+### 9.2 WO#
+
+| Formato legado | Estratégia |
+|----------------|------------|
+| Sequencial sync `10000001` | Normalizar 11 dígitos |
+| `WO-{date}-{random}` | Coexistência; novos só 11 dígitos |
+| Duplicatas | Resolução manual pré-go-live |
+
+### 9.3 WorkOrderType
+
+Mapear SQL existente → enum; NULL → default PO; Overdue = derivado.
+
+### 9.4 Rollback
+
+Migrations reversíveis; feature flag SHOC; snapshot pré-migration.
+
+---
+
+## 10. Volume Discovery e Search Scalability
+
+### 10.1 Volume Discovery (Fase 0 — gate Fase 1)
+
+**Sem premissa de volume.** Métricas obrigatórias:
+
+| Métrica | Gate |
+|---------|------|
+| Total WOs produção/staging | Obrigatório |
+| WOs/semana (p95) | Obrigatório |
+| WOs Unscheduled | Obrigatório |
+| Crescimento mensal | Desejável |
+
+### 10.2 Tiers e impacto
+
+| Tier | Total WOs | Listagem semanal | Advanced search |
+|------|-----------|------------------|-----------------|
+| **S** | < 25k | Índices simples | SQL filtros compostos |
+| **M** | 25k–250k | Índices covering | Paginação obrigatória |
+| **L** | 250k–1M | Read model candidato | Full-text |
+| **XL** | > 1M | Materialized view | Search dedicado (ARB) |
+
+Fases 1–3: índices conservadores compatíveis com qualquer tier. Fase 4: implementação conforme tier + load test.
+
+---
+
+## 11. Coexistência Multi-Consumidor
+
+### 11.1 Inventário
+
+| Consumidor | Conexão | Status |
+|------------|---------|--------|
+| **SHOC React** (`seahaven.desing`) | REST JWT | Em desenvolvimento — **único alvo novas features** |
+| **Blazor** (`SeaHavenIndustries`) | EF direto, não REST | Ativo — manutenção mínima; sunset WO |
+| **Vendor Portal UI** | REST `X-Vendor-Token` | API ativa; UI externa |
+| **SyncController + Lambda** | DynamoDB → SQL | Ponte temporária |
+| **E-mails SendGrid** | Deep links SHOC/Portal | Ativo |
+| **Mobile** | — | Sem evidência — confirmar com PO |
+
+```mermaid
+flowchart TB
+    SHOC[SHOC React] -->|REST JWT| API[Api REST]
+    VPortal[Vendor Portal] -->|X-Vendor-Token| API
+    Lambda[Lambda ingest] --> DynamoDB[(DynamoDB)]
+    DynamoDB --> Sync[SyncController]
+    Sync --> DB[(SQL Server)]
+    API --> DB
+    Blazor[Blazor EF] -->|legado| DB
+```
+
+**Nota:** DynamoDB é **ingestão externa**, não banco operacional. SQL Server é fonte para board, Blazor e Portal.
+
+### 11.2 Matriz de coexistência
+
+| Consumidor | Novas features board | Schema | Sunset |
+|------------|---------------------|--------|--------|
+| SHOC | Recebe tudo | Consome novos campos | Destino final |
+| Blazor | Não recebe | Colunas nullable; backward compatible | Módulo WO congela |
+| Vendor Portal | Não usa board | Dispatch intacto | Mantém |
+| Sync/Lambda | Indireto | Defaults para novos campos | Após cutover API |
+| E-mails | Links SHOC | FrontendBaseUrl prod | Atualizar templates |
+
+### 11.3 Trilhas de entrega
+
+- **Trilha A SHOC:** fases 0–7; feature flags; piloto dispatchers
+- **Trilha B Blazor:** smoke EF pós-migration; sem board; bugfix crítico only
+- **Trilha C Vendor Portal:** regression suite cada release que toca WO/Dispatch
+- **Trilha D Lambda:** manter até SHOC produção; cutover Fase 7; critério: criação WO + auth serviço estáveis
+
+### 11.4 Endpoints legado vs board
+
+- Legado (`GetWorkOrderList`, etc.): manter durante coexistência; congelar contrato
+- Board: novos contratos; não estender legado com hacks
+- Deprecação: após 100% dispatchers SHOC + sunset Blazor WO
+
+### 11.5 Ordem de rollout
+
+1. Fase 0 staging — gates + migrations
+2. Gate Blazor smoke EF
+3. Fase 1 staging — SHOC board feature flag
+4. Gate Vendor Portal regression
+5. Fases 2–6 incrementais
+6. Piloto 1–2 dispatchers
+7. Rollout gradual
+8. Sunset Blazor WO
+9. Cutover Lambda → API
+10. Deprecação legado + SyncController
+
+### 11.6 Monitoramento coexistência
+
+Métricas por consumidor; drift DynamoDB vs SQL; adoção SHOC vs Blazor; alertas job failure.
+
+### 11.7 Checklist pré-go-live PO
+
+- App mobile externo?
+- Data sunset Blazor WO
+- FrontendBaseUrl produção → SHOC
+- Owner Lambda cutover
+
+---
+
+## 12. Implementation Phases
+
+### Fase 0 — Domain Foundation + Governança
+
+**Objetivo:** Kickoff enterprise — domínio, ownership, volume, audit antes de board.
+
+**Escopo:** DAR; 3 artefatos (Ownership, Field Matrix, Audit Contract); Volume Discovery; drift SQL/EF; spike vendor; agregados Core+Scheduling+Tracking+Analytics+Completion; enums; RowVersion root+Dispatch; migration dry-run; ManualEditFlag design; audit baseline ChangeStatus/ChangeAssignment; smoke Blazor/Sync/Portal.
+
+**Não inicia:** Board API, inline edit, jobs.
+
+**Validação:** 9 gates assinados; audit granularidade testada; tier volume definido.
+
+---
+
+### Fase 1 — Weekly Board (leitura)
+
+**Objetivo:** Tela principal carrega semana operacional.
+
+**Escopo:** Listagem window-based; Unscheduled; 14 colunas como projeção; `X of Y`; filtros (dispatcher multi, `__unassigned__`, My WOs, tipo, semana); `isPastDue` derivado on-read; vendor via dispatch primário; índices conforme tier volume.
+
+**Validação:** 1 call = semana + Unscheduled; 12/14 colunas mínimo; gate Vendor Portal regression.
+
+---
+
+### Fase 2 — Inline Edit + Concorrência
+
+**Objetivo:** Edição spreadsheet com regras e conflitos tratados.
+
+**Escopo:** Update granular; dual RowVersion; audit 1 evento/campo; auto-schedule; rescheduleCount++; bloqueio PastDue flag; cancel read-only; WO# 11 dígitos; testes concorrência.
+
+---
+
+### Fase 3 — Criação e Cancelamento
+
+**Escopo:** Wizard/inline completo; Incomplete inicial; targetWeek; soft cancel; ManualEditFlag na criação; delete admin documentado.
+
+---
+
+### Fase 4 — Search
+
+**Escopo:** Busca contextual semana; advanced search cross-week conforme tier; load test; sem implementar advanced sem tier definido.
+
+---
+
+### Fase 5 — Scheduled Domain Events
+
+**Escopo:** WeekRolled → CarriedOver++; cache opcional PastDue; idempotência; monitoramento falha; on-read sempre correto.
+
+---
+
+### Fase 6 — Completion Doc e Slide-over
+
+**Escopo:** docStatus WO-level; templates por serviço; Comments/Audit/Media alinhados ao FE.
+
+---
+
+### Fase 7 — Rollout e Produção
+
+**Escopo:** Piloto; rollout gradual; sunset Blazor WO; cutover Lambda; deprecação legado; UAT; zero P1 duas semanas; dashboards saúde.
+
+---
+
+## 13. Critical Path Analysis
+
+### Must Have
+1. Listagem window-based + Unscheduled
+2. Projeção 14 colunas
+3. Agregados domínio + enums
+4. Update granular por campo
+5. Status 10 labels + flag PastDue
+6. Lookups
+7. Criação wizard
+8. WO# 11 dígitos
+9. DAR + 3 artefatos Fase 0
+
+### Should Have
+10. Domain events CarriedOver
+11. Advanced search
+12. Regras mutação completas
+13. Soft cancel enforcement
+14. docStatus WO-level
+15. Auth ativa
+
+### Nice to Have
+16. Reorder intra-dia persistido (FE local)
+17. Flags pessoais session-only
+18. Paginação 12/24/48/96
+19. Bulk select
+
+---
+
+## 14. Frontend Impact Assessment
+
+| Gap | UX | Severidade | Workaround |
+|-----|-----|------------|------------|
+| Sem listagem semanal | Tela inutilizável | Critical | Mock FE |
+| 14 colunas incompletas | Board ilegível | Critical | Nenhum em prod |
+| Sem inline edit | Core inoperante | Critical | Modal legado |
+| Sem advanced search | WOs históricos invisíveis | High | Busca por ID |
+| Status incompatíveis | Decisões erradas | Critical | Hardcode FE |
+| Sem jobs (derivados) | Badges stale se só client | High | On-read BE resolve PastDue |
+| Sem docStatus | COMP DOC vazia | High | Ocultar coluna |
+| WO# formato errado | Criação bloqueada | Critical | — |
+| Ownership Sync vs SHOC | Overwrite silencioso | Critical | Field Matrix Fase 0 |
+| Auth desabilitada | Risco segurança | High | API gateway |
+
+---
+
+## 15. Business Rules Assessment
+
+| Regra | Status | Impacto |
+|-------|--------|---------|
+| Auto-schedule Incomplete→Scheduled | Unsupported | Status incorreto |
+| Reschedule → rescheduleCount++ | Unsupported | Badge ↻ ausente |
+| Reschedule limpa PastDue (derivado) | Unsupported | Flag stale até re-read |
+| Status bloqueado se PastDue | Unsupported | Bypass via API |
+| WO# único 11 dígitos | Unsupported | Duplicatas |
+| Cancel read-only | Partial | Edição pós-cancel |
+| WeekRolled → carriedOver | Unsupported | Badge ↷N ausente |
+| Completion doc por serviço | Unsupported | Workflow manual |
+| Week-only scheduling | Unsupported | Wizard incompleto |
+
+---
+
+## 16. Data Contract Readiness
+
+| Área | Readiness % | Gap principal |
+|------|-------------|---------------|
+| List Views board | 5% | 14 colunas, schedule, vendor, flags |
+| Detail slide-over | 40% | Derivados, docStatus, schema |
+| Search | 10% | Cross-week, date ranges |
+| Lookups | 20% | initials, site code, PM, tech |
+| Scheduling | 25% | targetWeek, ScheduledEnd |
+| Status | 30% | 10 labels + flag |
+| Completion | 0% | docStatus, templates |
+| Comments | 60% | Schema |
+| Audit | 50% | type system, granularidade |
+| Media | 45% | category |
+
+**Média ponderada: ~28%**
+
+---
+
+## 17. Testing Strategy
+
+### Functional
+Board semanal, 14 colunas, filtros, inline por campo, regras negócio, criação/cancelamento, docStatus, status+flag, ownership rejection sync.
+
+### Integration
+SHOC E2E por fase; Vendor Portal regression; Sync; auth; dual RowVersion.
+
+### Regression
+Endpoints legados; Blazor smoke EF; Portal checklist/signoff.
+
+### UAT
+Roteiros dispatchers reais; sign-off PO por fase.
+
+### Data validation
+WO# migration; status mapping; derivados on-read vs contadores; referencial.
+
+### Migration validation
+Dump produção espelho; antes/depois contagens; rollback por fase.
+
+### Fase-specific
+- **0:** volume queries; audit granularidade; sync skip
+- **2:** concurrency suite; 409 handling
+- **4:** load test tier
+- **5:** job failure injection; on-read correctness
+
+---
+
+## 18. Risk Matrix
+
+| Risco | Prob. | Impacto | Mitigação |
+|-------|-------|---------|-----------|
+| Board inoperante em prod | Alta | Crítico | Fase 1 gate; E2E |
+| Ownership ambíguo Sync vs SHOC | Alta | Crítico | Field Ownership Matrix |
+| God Entity creep | Média | Alto | Growth Watchlist; ARB |
+| Conflito cross-agregado | Média | Alto | RowVersion root + Dispatch |
+| Job falha estado errado | Alta | Alto | Derivados on-read |
+| Vendor drift Dispatch vs WO | Alta | Crítico | Spike; projeção only |
+| Status migration incorreta | Média | Crítico | LegacyStatus; dry-run |
+| Volume desconhecido → índices errados | Alta | Alto | Volume Discovery Fase 0 |
+| Audit inútil investigação | Média | Médio | Event Contract |
+| Regressão Vendor Portal | Média | Crítico | Suite dedicada |
+| Blazor vs SHOC divergência | Alta | Alto | Congelar Blazor WO |
+| Auth bloqueia integrações | Média | Alto | Inventário consumidores |
+| CarriedOver recalculado errado | Baixa | Médio | Só via WeekRolled |
+| Scheduling aggregate creep | Média | Alto | Watchlist §4.2 |
+
+---
+
+## 19. Prioritized Backlog
+
+Ordenado por sequência de implementação.
+
+| # | Item | P | Fase | Dep | Complex. | Risco |
+|---|------|---|------|-----|----------|-------|
+| 1 | DAR completo + sign-off CTO | P0 | 0 | — | M | Alto |
+| 2 | Data Ownership Model | P0 | 0 | — | S | Alto |
+| 3 | Field Ownership Matrix + ManualEditFlag | P0 | 0 | 2 | M | Alto |
+| 4 | Audit Event Contract + baseline | P0 | 0 | — | M | Médio |
+| 5 | Volume Discovery Report | P0 | 0 | — | S | Alto |
+| 6 | Database drift SQL vs EF | P0 | 0 | — | M | Médio |
+| 7 | Spike vendor/dispatch source of truth | P0 | 0 | — | M | Alto |
+| 8 | Agregados domínio (anti God Entity) | P0 | 0 | 1 | L | Alto |
+| 9 | Matriz Persistido vs Derivado | P0 | 0 | 1 | S | Médio |
+| 10 | RowVersion root + Dispatch | P0 | 0 | 8 | M | Alto |
+| 11 | Enums Lifecycle + Flags + WorkOrderType | P0 | 0 | 8 | M | Médio |
+| 12 | Data migration dry-run | P0 | 0 | 8 | M | Alto |
+| 13 | Inventário consumidores + coexistência | P0 | 0 | — | S | Médio |
+| 14 | Smoke Blazor EF + Sync + Portal | P0 | 0 | 8 | M | Alto |
+| 15 | Normalização WO# 11 dígitos | P0 | 0 | 12 | M | Alto |
+| 16 | Reativar auth endpoints WO | P0 | 0 | — | S | Médio |
+| 17 | Lookups (dispatchers, sites, PM, tech) | P0 | 0–1 | — | M | Baixo |
+| 18 | Listagem window-based + Unscheduled | P0 | 1 | 8,11,17 | L | Alto |
+| 19 | Projeção 14 colunas | P0 | 1 | 18 | L | Alto |
+| 20 | isPastDue derivado on-read | P0 | 1 | 19 | S | Baixo |
+| 21 | Vendor via dispatch primário | P0 | 1 | 7,19 | M | Alto |
+| 22 | Filtros principais + My WOs | P0 | 1 | 18 | M | Médio |
+| 23 | Contador X of Y | P1 | 1 | 18 | S | Baixo |
+| 24 | Sync merge por field ownership | P0 | 0–1 | 3 | M | Alto |
+| 25 | Update granular inline | P0 | 2 | 19 | L | Alto |
+| 26 | Audit 1 evento por campo | P0 | 2 | 4,25 | M | Médio |
+| 27 | Concurrency integration tests | P0 | 2 | 10,25 | M | Alto |
+| 28 | Auto-schedule Incomplete→Scheduled | P0 | 2 | 25 | M | Médio |
+| 29 | RescheduleCount++ domain event | P0 | 2 | 25 | S | Baixo |
+| 30 | Bloqueio status se PastDue flag | P0 | 2 | 25 | S | Baixo |
+| 31 | Cancel read-only enforcement | P1 | 2 | 25 | S | Baixo |
+| 32 | Criação wizard/inline completa | P0 | 3 | 25 | M | Médio |
+| 33 | Week-only scheduling targetWeek | P1 | 3 | 32 | M | Médio |
+| 34 | Soft cancel dedicado | P1 | 3 | 31 | S | Baixo |
+| 35 | Busca contextual semana | P1 | 4 | 19 | M | Baixo |
+| 36 | Advanced search cross-week | P1 | 4 | 5,19 | L | Médio |
+| 37 | Load test search por tier | P0 | 4 | 5 | M | Alto |
+| 38 | WeekRolled domain event + CarriedOver | P1 | 5 | 8 | M | Médio |
+| 39 | Cache opcional PastDue | P2 | 5 | 20 | S | Baixo |
+| 40 | docStatus WO-level | P1 | 6 | 8 | M | Médio |
+| 41 | Completion templates por serviço | P2 | 6 | 40 | L | Médio |
+| 42 | Slide-over Comments/Audit/Media | P2 | 6 | 4,40 | M | Baixo |
+| 43 | Regression suite legado + Portal | P0 | cont. | — | M | Alto |
+| 44 | UAT dispatchers por fase | P0 | cont. | — | S | Médio |
+| 45 | Piloto + rollout gradual SHOC | P0 | 7 | 1–42 | M | Alto |
+| 46 | Sunset Blazor WO | P1 | 7 | 45 | S | Médio |
+| 47 | Cutover Lambda → API | P1 | 7 | 32 | M | Alto |
+| 48 | Deprecação endpoints legado + Sync | P2 | 7 | 45 | M | Médio |
+| 49 | Monitoramento coexistência | P1 | 7 | 45 | S | Baixo |
+
+---
+
+## 20. Cronograma indicativo
+
+```mermaid
+gantt
+    title Work Orders Board
+    dateFormat YYYY-MM-DD
+    section Fundacao
+    DAR_arteFatos_dominio     :2026-07-01, 8w
+    section Board
+    Listagem_14colunas        :2026-09-01, 8w
+    section Mutacao
+    Inline_concorrencia       :2026-11-01, 8w
+    Criacao_cancelamento      :2026-11-15, 6w
+    section Inteligencia
+    Search                    :2027-01-01, 6w
+    Domain_events             :2027-01-15, 4w
+    section Completion
+    DocStatus_slideover       :2027-02-15, 6w
+    section Producao
+    Piloto_rollout            :2027-04-01, 8w
+```
+
+---
+
+## 21. Stakeholders
+
+| Papel | Responsabilidade |
+|-------|------------------|
+| CEO / Sponsor | Investimento XL; prioridade SHOC sobre Blazor |
+| Product Owner | Aceite por fase; semana operacional; regras ambíguas |
+| CTO / Arquiteto | DAR; 3 artefatos; ownership; cutover Lambda |
+| Backend | Fases 0–6 domínio e contratos |
+| Frontend SHOC | Integração; feature flags; remover mocks |
+| QA | Testes §17; UAT; concurrency |
+| Documentação | Contratos; guia consumidores legados |
+| Operações | Jobs; alertas; monitoramento coexistência |
+
+---
+
+## 22. Critérios de prontidão para kickoff (9.5+)
+
+| Área | Critério |
+|------|----------|
+| Domain Design | DAR aprovado; agregados; Watchlist |
+| Source of Truth | Field Ownership Matrix assinada |
+| Data Governance | Data Ownership Model completo |
+| Concurrency | RowVersion root + Dispatch; testes Fase 2 |
+| Sync | Cenários explícitos; ManualEditFlag |
+| Audit | Event Contract; 1 evento/campo inline |
+| Migration | Dry-run; LegacyStatus rollback |
+| Volume | Discovery Fase 0; tier definido |
+| Jobs | Domain events; on-read correto se job falha |
+| Coexistência | Inventário; trilhas; smoke Blazor/Portal/Sync |
+
+---
+
+## 23. Conclusão
+
+Programa **viável e de grande porte (XL)**. O caminho crítico é:
+
+```text
+Resolver domínio e governança (Fase 0)
+  → Board semanal (Fase 1)
+    → Inline edit + concorrência (Fase 2)
+      → Paridade funcional progressiva (Fases 3–6)
+        → Rollout seguro (Fase 7)
+```
+
+O documento integra: gap assessment da auditoria, modelo de domínio com agregados, governança de ownership, concorrência multi-agregado, migração de dados, coexistência SHOC/Blazor/Portal/Lambda, e backlog executável — pronto para Architecture Review Board e kickoff de implementação enterprise.
+
+**Próximo passo imediato:** executar Fase 0 — produzir e assinar os três artefatos (Data Ownership Model, Field Ownership Matrix, Audit Event Contract) antes de qualquer migration de schema.
diff --git a/docs/spikes/search-strategy.md b/docs/spikes/search-strategy.md
new file mode 100644
index 0000000..273e32d
--- /dev/null
+++ b/docs/spikes/search-strategy.md
@@ -0,0 +1,181 @@
+# Spike Search Strategy — `GetWorkOrdersBoard`
+
+**Data:** 2026-06-19  
+**Gate:** G3 (pré-requisito Fase 1)  
+**Objetivo:** Definir busca mínima viável para o Schedule Board sem degradar performance.
+
+---
+
+## Estado atual (`GetWorkOrderList`)
+
+Implementação em `SeaHaven.DataServices/Implementation/WorkOrderDataService.cs` (`GetWorkOrderListPagedAsync`):
+
+| Aspecto | Comportamento atual |
+|---------|---------------------|
+| Paginação | `page` / `pageSize` (default 12), sem cap |
+| Janela temporal | **Ausente** — sem filtro `ScheduledDate` |
+| Search | `Contains` + `ToLower()` em 5 campos |
+| Campos search | `InternalWONumber`, `WorkerOrderNumber`, `WorkerOrderTitle`, `Locations.Title`, `Locations.Name` |
+| Campos omitidos | `SiteCode`, `Trade`, `Problem`, vendor, dispatcher por ID |
+| Joins | `Locations`, `AssignToUser` (AspNetUsers) |
+| Vendor/dispatch | **Não incluídos** |
+| Projeção extra | Subquery `lastUpdated` via Comments + WorkOrderAuditLogs por linha |
+
+### Padrão SQL gerado (search)
+
+```sql
+WHERE LOWER(InternalWONumber) LIKE '%term%'
+   OR LOWER(WorkerOrderNumber) LIKE '%term%'
+   OR LOWER(WorkerOrderTitle) LIKE '%term%'
+   OR LOWER(Locations.Name) LIKE '%term%'
+   ...
+```
+
+Leading wildcard → table scan em colunas `nvarchar(max)`.
+
+---
+
+## Respostas às perguntas do spike
+
+| # | Pergunta | Decisão Fase 1 |
+|---|----------|----------------|
+| S1 | Volume típico por semana | Assumir **< 200 WOs/semana** até medir em prod; threshold fallback = **300** |
+| S2 | Campos pesquisáveis mínimos | `internalWONumber`, `siteCode`, `assigneeId[]` (exato), `locationId` |
+| S3 | LIKE vs full-text | **Sem full-text** Fase 1; `StartsWith` em WO# e siteCode; evitar `Contains` em title/location no servidor |
+| S4 | Escopo | Search **sempre scoped** a `scheduledFrom` / `scheduledTo` (obrigatório no endpoint) |
+| S5 | Vendor/tech no search | **Fase 2** — exige join `Dispatches → Vendor` |
+
+---
+
+## Estratégia em 2 camadas
+
+```
+Request GetWorkOrdersBoard
+  │
+  ├─► 1. Filtro janela ScheduledDate (obrigatório)
+  │
+  ├─► 2. Filtros exatos: status, assigneeId[], locationId
+  │
+  ├─► 3. COUNT no escopo
+  │
+  ├─► count <= 300?
+  │     ├─ SIM → retornar semana inteira (sem paginação Fase 1)
+  │     │         search textual extra no FE: title, locationLabel, serviceType
+  │     └─ NÃO → exigir critério indexável no servidor
+  │               (woNumber ou siteCode StartsWith)
+  │
+  └─► Response: { scheduledFrom, scheduledTo, totalCount, items[] }
+```
+
+### Campos Fase 1 vs Fase 2
+
+| Campo | Fase 1 (servidor) | Fase 1 (client fallback) | Fase 2 |
+|-------|-------------------|--------------------------|--------|
+| `internalWONumber` / `workerOrderNumber` | `StartsWith` | — | — |
+| `siteCode` | `StartsWith` ou igualdade | — | — |
+| `assigneeId` | multi-select exato | — | — |
+| `locationId` | exato | — | — |
+| `status` | exato / multi | pills client-side | — |
+| `workerOrderTitle` | — | client-side se count ≤ 300 | server `Contains` opcional |
+| `locationLabel` | — | client-side | — |
+| `serviceType` (trade/category) | — | client-side | server join |
+| `vendorCompany` / `vendorTechnician` | — | — | join Dispatch→Vendor |
+| `assigneeName` | — | client-side | evitar join por nome |
+
+---
+
+## Query plan esperado (Fase 1)
+
+### Caminho feliz (semana típica, ≤ 300 rows)
+
+1. **Index seek** em `IX_workOrders_ScheduledDate` (proposto) com range `[scheduledFrom, scheduledTo+1day)`
+2. Filtro `istemplate != true`
+3. Filtros exatos em `AssignTo`, `LocationId`, `Status` (AND)
+4. **Sem** search textual no servidor se `search` vazio
+5. Join LEFT `Locations`, `AssignToUser`, LEFT `Dispatches` + `Vendor` (Fase 1 board — vendor no DTO, não no search)
+6. Projeção flat para `WorkOrderBoardRowDto` — **sem** subquery `lastUpdated`
+
+### Caminho search servidor (count > 300 ou user digitou termo indexável)
+
+1. Mesma janela + filtros exatos
+2. AND (`InternalWONumber LIKE 'term%'` OR `SiteCode LIKE 'term%'`)
+3. Se count ainda > 300 → HTTP 400 com mensagem "Refine search or narrow date window"
+
+### Anti-padrões proibidos no board endpoint
+
+- `pageSize=500` como gambiarra de fetch semanal
+- `Contains('%x%')` em múltiplas tabelas sem janela temporal
+- Filtro assignee por nome concatenado (`FirstName + LastName`) — usar `assigneeId`
+- Subquery correlated Comments/AuditLog por row
+
+---
+
+## Índices recomendados
+
+Migration separada **após aprovação** desta spike (não incluir na Fase 1 code sem review):
+
+| Índice | Coluna(s) | Prioridade | Nota |
+|--------|-----------|------------|------|
+| `IX_workOrders_ScheduledDate` | `ScheduledDate` | **P1** | Filtro de janela do board |
+| `IX_workOrders_InternalWONumber` | `InternalWONumber` | P2 | Requer alterar coluna de `nvarchar(max)` → `nvarchar(50)` |
+| `IX_workOrders_SiteCode` | `SiteCode` | P2 | Idem — tamanho fixo ~50 |
+| `IX_workOrders_AssignTo` | `AssignTo` | existente | Multi-select dispatcher |
+| `IX_workOrders_LocationId` | `LocationId` | existente | Filtro location |
+
+**Full-text index:** não recomendado Fase 1 — volume semanal baixo + fallback client-side suficiente.
+
+---
+
+## Referência de implementação
+
+Copiar padrão de janela temporal de `DispatchController.List`:
+
+```csharp
+if (dateFrom.HasValue)
+    q = q.Where(d => d.DispatchedAt >= dateFrom.Value);
+if (dateTo.HasValue)
+{
+    var end = dateTo.Value.Date.AddDays(1);
+    q = q.Where(d => d.DispatchedAt < end);
+}
+```
+
+Adaptar para `WorkOrder.ScheduledDate` no board endpoint.
+
+---
+
+## Parâmetros propostos — `GetWorkOrdersBoard`
+
+| Parâmetro | Tipo | Obrigatório | Descrição |
+|-----------|------|-------------|-----------|
+| `scheduledFrom` | `DateOnly` | **Sim** | Início da semana/janela |
+| `scheduledTo` | `DateOnly` | **Sim** | Fim da janela (inclusivo) |
+| `search` | `string` | Não | WO# ou siteCode prefix |
+| `assignee` | `string[]` | Não | IDs de dispatcher (multi) |
+| `status` | `string[]` | Não | Status canônico API |
+| `locationId` | `int?` | Não | Filtro location |
+
+**Limite hard janela:** max **90 dias** (Fase 2 advanced search cross-week).
+
+---
+
+## Threshold e fallback
+
+| Constante | Valor | Justificativa |
+|-----------|-------|---------------|
+| `BoardSearchClientSideThreshold` | **300** | Payload ~300 rows × ~500 bytes ≈ 150 KB — aceitável para 1 call/semana |
+| Sem paginação Fase 1 | — | Janela semanal é o filtro natural |
+| Paginação Fase 2 | cursor/offset | Só quando janela > 1 semana com search global |
+
+---
+
+## Conclusão
+
+Fase 1 adota **window-first, search-second**:
+
+1. Janela `ScheduledDate` obrigatória + índice dedicado
+2. Search servidor mínimo (`StartsWith` em identificadores)
+3. Fallback client-side para campos ricos quando count ≤ 300
+4. Vendor/tech e full-text adiados para Fase 2
+
+Esta estratégia desbloqueia `GetWorkOrdersBoard` sem replicar os anti-padrões de `GetWorkOrderListPagedAsync`.
diff --git a/docs/work-orders/phase-0/README.md b/docs/work-orders/phase-0/README.md
new file mode 100644
index 0000000..239469e
--- /dev/null
+++ b/docs/work-orders/phase-0/README.md
@@ -0,0 +1,32 @@
+# Fase 0 — Work Orders Foundation
+
+Documentação e gates da Fase 0 (Domain Foundation + Governança).
+
+## Governança
+
+- [DAR — Domain Architecture Review](dar-domain-architecture-review.md)
+- [Matriz Persistido vs Derivado](dar-persisted-vs-derived-matrix.md)
+- [Data Ownership Model](data-ownership-model.md)
+- [Field Ownership Matrix](field-ownership-matrix.md)
+- [ManualEditFlag Design](manual-edit-flag-design.md)
+- [Audit Event Contract](audit-event-contract.md)
+
+## Discovery
+
+- [Volume Discovery Report](volume-discovery-report.md)
+- [Database Drift Report](database-drift-report.md)
+- [Consumer Inventory](consumer-inventory.md)
+- [ADR Vendor Source of Truth](adr-vendor-source-of-truth.md)
+
+## Validação
+
+- [RowVersion Design](rowversion-design.md)
+- [Migration Dry-Run Report](migration-dry-run-report.md)
+- [Smoke Checklist](smoke-checklist.md)
+- [Gates Sign-Off](phase-0-gates-signoff.md)
+
+## Código entregue
+
+- Migration: `Data.SeaHavenIndustries/Migrations/20260624163145_Phase0_DomainFoundation.cs`
+- Serviços: `IWorkOrderAuditService`, `IWorkOrderFieldLockService`, `ISyncFieldMergePolicy`
+- Testes: `SeaHavenIndustries.Tests` (12 testes)
diff --git a/docs/work-orders/phase-0/adr-vendor-source-of-truth.md b/docs/work-orders/phase-0/adr-vendor-source-of-truth.md
new file mode 100644
index 0000000..6dbafa9
--- /dev/null
+++ b/docs/work-orders/phase-0/adr-vendor-source-of-truth.md
@@ -0,0 +1,67 @@
+# ADR — Vendor Source of Truth
+
+**Status:** Accepted (Fase 0 spike)  
+**Decisores:** Backend + Arquiteto
+
+---
+
+## Contexto
+
+O board SHOC exibe colunas VENDOR e APPT na listagem semanal. Hoje vendor existe apenas no agregado Dispatch; a entidade WorkOrder não possui referência ao dispatch primário.
+
+---
+
+## Decisão
+
+1. **WorkOrder.PrimaryDispatchId** (nullable FK → Dispatches) identifica o dispatch canônico para projeção board.
+2. Colunas VENDOR/APPT = **projeção read-only** via join no dispatch primário (Vendor.Name, Dispatch.ScheduledDate).
+3. Edição inline vendor (Fase 2) muta **Dispatch**, não WorkOrder. Bump `Dispatch.RowVersion`.
+4. WO sem dispatch: primeira edição vendor cria dispatch primário e seta `PrimaryDispatchId`.
+5. **Proibido** adicionar VendorId, TechName, TechPhone na tabela workOrders.
+
+---
+
+## Query de projeção (spike)
+
+```sql
+SELECT wo.Id,
+       wo.InternalWONumber,
+       d.Id AS DispatchId,
+       v.Name AS VendorName,
+       d.ScheduledDate AS ApptDate,
+       d.Status AS DispatchStatus
+FROM workOrders wo
+LEFT JOIN Dispatches d ON d.Id = wo.PrimaryDispatchId
+LEFT JOIN Vendors v ON v.Id = d.VendorId
+WHERE wo.IsDeleted IS NULL OR wo.IsDeleted = 0;
+```
+
+Implementação C# em `DispatchDataService.GetPrimaryDispatchProjectionAsync(workOrderId)` (Fase 1).
+
+---
+
+## Seleção do dispatch primário
+
+| Cenário | Regra |
+|---------|-------|
+| PrimaryDispatchId setado | Usar esse dispatch |
+| Null + exatamente 1 dispatch | Auto-set PrimaryDispatchId na migration backfill |
+| Null + N dispatches | Usar dispatch mais recente por DispatchedAt; log para revisão manual |
+| Zero dispatches | Vendor columns vazias no board |
+
+---
+
+## Consequências
+
+- **Positivo:** Zero drift vendor WO vs Dispatch; Portal regression isolada.
+- **Negativo:** Join extra na listagem board — mitigado por índice em PrimaryDispatchId.
+- **Fase 0:** Coluna + FK + backfill script no dry-run; endpoint board na Fase 1.
+
+---
+
+## Critérios de aceite spike
+
+- [x] ADR documentado
+- [x] Query prototipada
+- [ ] PrimaryDispatchId na migration Phase0
+- [ ] Backfill documentado no dry-run report
diff --git a/docs/work-orders/phase-0/audit-event-contract.md b/docs/work-orders/phase-0/audit-event-contract.md
new file mode 100644
index 0000000..bb773f4
--- /dev/null
+++ b/docs/work-orders/phase-0/audit-event-contract.md
@@ -0,0 +1,106 @@
+# Audit Event Contract — Work Orders
+
+**Fase:** 0  
+**Status:** Aprovado para implementação baseline  
+**Schema EF:** `WorkOrderAuditLog` estendido
+
+---
+
+## 1. Princípios
+
+- Toda mutação gera audit **síncrono** desde Fase 0.
+- Edição inline (Fase 2) = **1 evento por campo**.
+- Audit serve investigação operacional, não só compliance.
+
+---
+
+## 2. Schema por evento
+
+| Campo | Tipo | Obrigatório |
+|-------|------|-------------|
+| Id | int | Sim (PK) |
+| WorkOrderId | int | Sim |
+| EventType | enum string | Sim: Manual, System, Sync, Vendor |
+| Action | string | Sim: FieldChanged, StatusChanged, WeekRolled, SyncRejected, AssignmentChanged |
+| FieldName | string | Sim para inline / field change |
+| OldValue | string | Sim |
+| NewValue | string | Sim |
+| UserId / ActorId | string | Sim para Manual |
+| ActorType | enum string | Sim: Dispatcher, Vendor, System, Sync |
+| CreatedAt | DateTime UTC | Sim |
+| CorrelationId | string | Recomendado |
+| DispatchId | int? | Quando evento é no dispatch |
+
+**Compatibilidade:** colunas `Action` legada mapeada para novo `Action`; `UserId` = ActorId para Manual.
+
+---
+
+## 3. Enums
+
+```csharp
+AuditEventType: Manual | System | Sync | Vendor
+AuditActorType: Dispatcher | Vendor | System | Sync
+AuditActionType: FieldChanged | StatusChanged | AssignmentChanged | WeekRolled | SyncRejected | Create | Delete
+```
+
+---
+
+## 4. Mutação → eventos
+
+| Mutação | Eventos |
+|---------|---------|
+| ChangeStatus | 1× StatusChanged (EventType=Manual) |
+| ChangeAssignment | 1× AssignmentChanged (FieldName=AssignTo) |
+| Inline cell (Fase 2) | 1× FieldChanged por campo |
+| Auto-schedule (Fase 2) | StatusChanged + FieldChanged se aplicável |
+| Reschedule (Fase 2) | FieldChanged + analytics |
+| WeekRolled (Fase 5) | System WeekRolled + CarriedOver |
+| Sync skip | Sync SyncRejected |
+| Vendor checklist | Vendor FieldChanged + DispatchId |
+
+---
+
+## 5. Contrato FE (Audit tab)
+
+```typescript
+interface AuditEntry {
+  type: 'manual' | 'system' | 'sync' | 'vendor';
+  dispatcherId?: string;
+  action: string;
+  fieldName?: string;
+  oldValue: string;
+  newValue: string;
+  time: string; // ISO UTC
+  dispatchId?: number;
+}
+```
+
+Mapeamento API → FE:
+
+| API EventType | FE type |
+|---------------|---------|
+| Manual | manual |
+| System | system |
+| Sync | sync |
+| Vendor | vendor |
+
+---
+
+## 6. Baseline Fase 0 (endpoints)
+
+| Endpoint | Garantia |
+|----------|----------|
+| POST ChangeStatus | 1 audit StatusChanged; Old/New preenchidos |
+| POST ChangeAssignment | 1 audit AssignmentChanged; nomes usuário em Old/New |
+
+Implementação via `IWorkOrderAuditService`.
+
+---
+
+## 7. Critérios de aceite
+
+- [ ] Migration estende WorkOrderAuditLog
+- [ ] ChangeStatus/ChangeAssignment usam serviço central
+- [ ] Testes assertam 1 evento por mutação
+
+**Assinatura Backend Lead:** _________________ Data: _______
diff --git a/docs/work-orders/phase-0/consumer-inventory.md b/docs/work-orders/phase-0/consumer-inventory.md
new file mode 100644
index 0000000..5d1e35d
--- /dev/null
+++ b/docs/work-orders/phase-0/consumer-inventory.md
@@ -0,0 +1,85 @@
+# Consumer Inventory — Work Orders
+
+**Fase:** 0  
+**Referência:** roadmap §11
+
+---
+
+## 1. Inventário de consumidores
+
+| Consumidor | Conexão | Código principal | Campos mutados | Audit hoje? |
+|------------|---------|------------------|----------------|-------------|
+| **SHOC React** | REST JWT | `Api.SeaHavenIndustries/Controllers/WorkOrderController.cs` | Status, AssignTo, CRUD parcial via Service | Parcial (ChangeStatus/Assignment) |
+| **Blazor** | EF direto | `SeaHavenIndustries/Data/Services/WorkorderService.cs` | CRUD completo, comments, status | **Não** |
+| **Vendor Portal** | REST token | `Api.SeaHavenIndustries/Controllers/VendorPortalController.cs` | Dispatch checklist, signoff, status | Sim (ad hoc) |
+| **Sync/Lambda** | DynamoDB → SQL | `Api.SeaHavenIndustries/Controllers/SyncController.cs` | Upsert WO por ExternalWorkOrderId | **Não** |
+| **Dispatch API** | REST | `DispatchController.cs` | Dispatch create/update/verify | Sim |
+| **E-mail SendGrid** | Deep links | `Helper/SendMessage` | Nenhum (read-only links) | N/A |
+
+---
+
+## 2. Diagrama
+
+```mermaid
+flowchart TB
+    SHOC[SHOC_React] -->|REST_JWT| API[Api_REST]
+    VPortal[Vendor_Portal] -->|X_Vendor_Token| API
+    Lambda[Lambda_ingest] --> DynamoDB[(DynamoDB)]
+    DynamoDB --> Sync[SyncController]
+    Sync --> DB[(SQL_Server)]
+    API --> DB
+    Blazor[Blazor_EF] -->|legado| DB
+```
+
+---
+
+## 3. Trilhas de entrega (coexistência)
+
+| Trilha | Escopo Fase 0+ |
+|--------|----------------|
+| **A — SHOC** | Fases 0–7; feature flags; piloto dispatchers |
+| **B — Blazor** | Smoke EF pós-migration; bugfix crítico only |
+| **C — Vendor Portal** | Regression checklist cada release WO/Dispatch |
+| **D — Lambda/Sync** | Manter até SHOC produção; merge policy Fase 0 |
+
+---
+
+## 4. Endpoints legado vs board
+
+| Tipo | Exemplos | Política |
+|------|----------|----------|
+| Legado | GetWorkOrderList, ChangeStatus | Congelar contrato |
+| Board (Fase 1+) | GetWorkOrdersBoard | Novos contratos separados |
+
+---
+
+## 5. Gaps Fase 0 endereçados
+
+| Gap | Mitigação |
+|-----|-----------|
+| Blazor sem audit | Congelar; não expandir |
+| Sync overwrite | ISyncFieldMergePolicy + ManualEditFlag |
+| Auth WO desabilitada | Reativar `[Authorize]` WorkOrderController |
+| WO# inconsistente | Documentar normalização 11 dígitos (Fase 2 execução) |
+
+---
+
+## 6. Checklist pré-go-live PO
+
+- [ ] App mobile externo confirmado?
+- [ ] Data sunset Blazor WO definida?
+- [ ] FrontendBaseUrl produção → SHOC?
+- [ ] Owner Lambda cutover nomeado?
+
+---
+
+## 7. Auth — consumidores e tokens
+
+| Consumidor | Auth |
+|------------|------|
+| SHOC | JWT Bearer |
+| Sync | JWT Bearer (`[Authorize]` no SyncController) |
+| Vendor Portal | X-Vendor-Token (rotas públicas dispatch) |
+| Blazor | Cookie Identity (app separado) |
+
+Reativar auth em WorkOrderController exige SHOC enviar JWT em todas as chamadas WO.
diff --git a/docs/work-orders/phase-0/dar-domain-architecture-review.md b/docs/work-orders/phase-0/dar-domain-architecture-review.md
new file mode 100644
index 0000000..481a20e
--- /dev/null
+++ b/docs/work-orders/phase-0/dar-domain-architecture-review.md
@@ -0,0 +1,139 @@
+# DAR — Domain Architecture Review (Work Orders)
+
+**Fase:** 0  
+**Status:** Draft para sign-off CTO  
+**Referência:** [roadmap-work-orders-board.md](../../roadmap-work-orders-board.md) §4–5
+
+---
+
+## 1. Objetivo
+
+Formalizar o modelo de domínio operacional do Schedule Board antes de qualquer migration de schema board ou contrato de listagem semanal.
+
+---
+
+## 2. Agregados e limites (anti God Entity)
+
+```mermaid
+flowchart TB
+    subgraph root [AggregateRoot_WorkOrder]
+        CORE[Core_Lifecycle_Assignment]
+        SCH[Scheduling_slice]
+        TRK[Tracking_slice]
+        COMP[Completion_slice]
+        ANA[Analytics_slice]
+    end
+    subgraph separate [Agregado_separado]
+        DISP[Dispatch_fonte_vendor]
+    end
+    AUD[WorkOrderAuditLog_append_only]
+    CORE --> SCH
+    CORE --> TRK
+    CORE --> ANA
+    CORE --> COMP
+    CORE --> DISP
+    CORE --> AUD
+```
+
+| Agregado / Slice | Responsabilidade | Persistência Fase 0 |
+|------------------|------------------|---------------------|
+| **Core** | Id, WoNumber, Type, LifecycleStatus, SiteCode, LocationId, DueDate, AssignTo, Title, RowVersion, PrimaryDispatchId | Colunas em `workOrders` |
+| **Scheduling** | ScheduledDate, ScheduledStart/End, TargetWeek, ScheduleWeekOnly | Colunas em `workOrders` |
+| **Tracking** | OriginalWeek, OriginalDate (set-once) | Colunas em `workOrders` |
+| **Analytics** | RescheduleCount, CarriedOver | Colunas em `workOrders` |
+| **Completion** | DocStatus, refs attachments | Coluna DocStatus + attachments existentes |
+| **Dispatch** | Vendor, tech, status portal | Tabela `Dispatches` + RowVersion |
+| **Audit** | Rastreabilidade imutável | `WorkOrderAuditLogs` |
+
+**Proibido:** `VendorId`, `TechName`, `TechPhone` canônicos na entidade WorkOrder. Vendor sempre via Dispatch primário.
+
+---
+
+## 3. Fonte da verdade por conceito
+
+| Conceito | Fonte da verdade | Proibido |
+|----------|------------------|----------|
+| Status operacional | `LifecycleStatus` (10 valores FE) | String livre `Status` como canônico |
+| Past Due | Derivado on-read (`ScheduledDate < hoje` AND NOT terminal) | Misturar no enum lifecycle |
+| Vendor / Tech | Dispatch primário (`PrimaryDispatchId`) | Duplicar na WO |
+| Schedule | Scheduling slice | Duplicar no core sem slice lógico |
+| Completion | `DocStatus` | Inferir só de dispatch signoff |
+| Reschedule / CarriedOver | Analytics + domain events | Job blind overwrite |
+| WO# | `InternalWONumber` / `WorkerOrderNumber` com regra 11 dígitos (Fase 2+) | Dois números sem regra |
+| POC | `WorkOrderContacts` + Notes | Só no detalhe sem contato |
+
+---
+
+## 4. Lifecycle Status vs Operational Flags
+
+```text
+LifecycleStatus  → enum único (10 valores alinhados ao frontend)
+OperationalFlags → PastDue (derivado on-read; cache opcional Fase 5)
+LegacyStatus     → string original read-only (migration Fase 0)
+```
+
+Filtro de status no board = `LifecycleStatus`. Overlay Past Due = flag derivada. Bloqueio de edição = validação sobre flag (Fase 2).
+
+### Mapeamento legado → LifecycleStatus
+
+| Legado (`Status`) | LifecycleStatus |
+|-------------------|-----------------|
+| Open | Incomplete |
+| InProgress / In Progress | InProgress |
+| Completed / Complete | Complete |
+| Cancelled / Canceled | Canceled |
+| OnHold / On Hold | OnHold |
+| Desconhecido | Incomplete + NeedsReview |
+
+---
+
+## 5. CarriedOver — justificativa
+
+| | isPastDue | carriedOver |
+|--|-----------|-------------|
+| Natureza | Estado pontual | Métrica histórica acumulada |
+| Persistir | Não (derivado) | Sim (contador) |
+| Incremento | N/A | Somente via domain event `WeekRolled` (Fase 5) |
+
+---
+
+## 6. Scheduling Aggregate Growth Watchlist
+
+Campos que **não** entram em Scheduling sem ARB review:
+
+- `MoveReason`, `MoveUser`, `MoveCategory`, `MoveSource`
+
+Metadados de movimentação → Audit Event Contract.
+
+**Gate:** slice Scheduling > 8 campos operacionais → ARB obrigatório.  
+Contagem Fase 0: ScheduledDate, ScheduledStart, ScheduledEnd, TargetWeek, ScheduleWeekOnly, OriginalWeek, OriginalDate (tracking separado) — dentro do limite.
+
+---
+
+## 7. Jobs — domínio primeiro
+
+| Job | Papel |
+|-----|-------|
+| Past Due diário | Cache refresh opcional; on-read sempre correto |
+| Carried Over semanal | Dispara `WeekRolled` → incrementa contador + audit system |
+| Promoção Overdue type | Derivado on-read |
+| Audit | Síncrono em toda mutação desde Fase 0 |
+
+**Regra de ouro:** Jobs nunca são a única fonte da verdade.
+
+---
+
+## 8. Critérios de aceite (sign-off CTO)
+
+- [ ] Zero campos vendor canônicos na WO
+- [ ] Agregados documentados e refletidos no schema Fase 0
+- [ ] Persistido vs derivado validado com PO (ver `dar-persisted-vs-derived-matrix.md`)
+- [ ] Watchlist Scheduling registrada
+- [ ] Blazor congelado — sem novos campos board via EF direto
+
+**Assinaturas**
+
+| Papel | Nome | Data |
+|-------|------|------|
+| CTO / Arquiteto | | |
+| Product Owner | | |
diff --git a/docs/work-orders/phase-0/dar-persisted-vs-derived-matrix.md b/docs/work-orders/phase-0/dar-persisted-vs-derived-matrix.md
new file mode 100644
index 0000000..ceef146
--- /dev/null
+++ b/docs/work-orders/phase-0/dar-persisted-vs-derived-matrix.md
@@ -0,0 +1,54 @@
+# DAR — Matriz Persistido vs Derivado
+
+**Fase:** 0  
+**Status:** Draft para validação PO + CTO
+
+---
+
+## Matriz de campos (board + domínio)
+
+| Campo FE / conceito | Persistido | Derivado | Fonte / Regra |
+|---------------------|------------|----------|---------------|
+| lifecycleStatus | Sim | Não | Core — `LifecycleStatus` enum |
+| isPastDue | Não | **Sim** | `ScheduledDate < UTC hoje` AND NOT status terminal |
+| type (Overdue) | Parcial | **Sim** | Regra type + schedule + status |
+| workOrderType | Sim | Não | Core — enum `WorkOrderType` |
+| carriedOver | Sim | Não | Analytics — incremento via `WeekRolled` only |
+| rescheduleCount | Sim | Parcial | Analytics — incremento em mudança ScheduledDate |
+| docStatus | Sim | Não | Completion slice |
+| dayGroup | Não | Sim | Calculado na leitura a partir de ScheduledDate |
+| apptTime | Não | Sim | Projeção Dispatch primário ScheduledDate/Start |
+| vendorName / tech | Não | Sim (projeção) | Join Dispatch primário |
+| targetWeek | Sim | Não | Scheduling slice |
+| scheduledEnd | Sim | Não | Scheduling slice |
+| originalWeek / originalDate | Sim | Não | Tracking — set-once na primeira agenda |
+| operationalFlags.pastDue | Não* | Sim | *Cache opcional Fase 5; on-read authoritative |
+| legacyStatus | Sim (read-only) | Não | Valor string original pré-migration |
+
+---
+
+## Regras de derivação (on-read)
+
+### isPastDue
+
+```text
+isPastDue = ScheduledDate.HasValue
+         AND ScheduledDate.Value.Date < DateTime.UtcNow.Date
+         AND LifecycleStatus NOT IN (Complete, Canceled)
+```
+
+### type Overdue (derivado)
+
+WO com type != Overdue pode exibir badge Overdue quando isPastDue && regras de negócio PO confirmadas.
+
+---
+
+## Validação PO
+
+| Pergunta | Resposta PO |
+|----------|-------------|
+| Past Due separado do lifecycle status? | Sim |
+| carriedOver persiste mesmo após reschedule? | Sim |
+| Vendor nunca duplicado na WO? | Sim |
+
+**Assinatura PO:** _________________ Data: _______
diff --git a/docs/work-orders/phase-0/data-ownership-model.md b/docs/work-orders/phase-0/data-ownership-model.md
new file mode 100644
index 0000000..1c15bbf
--- /dev/null
+++ b/docs/work-orders/phase-0/data-ownership-model.md
@@ -0,0 +1,75 @@
+# Data Ownership Model — Work Orders
+
+**Fase:** 0  
+**Status:** Draft para sign-off CTO
+
+---
+
+## 1. Princípios
+
+1. **SHOC (React)** é o único destino de novas features do board.
+2. **SQL Server** é fonte operacional para board, Blazor e Portal.
+3. **DynamoDB/Sync** é ponte temporária de ingestão externa.
+4. Conflito entre atores resolve-se pela Field Ownership Matrix, não por last-write-wins global.
+
+---
+
+## 2. Ownership por ator
+
+| Ator | Conexão | Pode alterar | Não pode alterar |
+|------|---------|--------------|------------------|
+| **SHOC** | REST JWT (`api/WorkOrder`) | Lifecycle, Schedule, Assignment, Completion, vendor via Dispatch, POC, WO# | Checklist/signoff vendor |
+| **Vendor Portal** | REST `X-Vendor-Token` | Dispatch status, checklist, signoff, comments vendor | Schedule, lifecycle, assignment, DueDate |
+| **Sync/Lambda** | `POST api/Sync/WorkOrders` | Campos ingest (Description, ExternalId, SiteCode na criação, etc.) | Campos SHOC-owned após ManualEditFlag |
+| **Blazor** | EF direto (`WorkorderService`) | Campos legados existentes até sunset | Campos novos board; **congelado** |
+| **Jobs** | Domain events (Fase 5+) | Incremento CarriedOver; audit System | Lifecycle, Schedule, Dispatch |
+
+---
+
+## 3. Política Blazor (sunset)
+
+- Manutenção mínima: bugfix crítico only.
+- Não recebe: board, inline edit, jobs, advanced search, completion doc WO-level.
+- Schema: colunas novas Fase 0 são **nullable** — Blazor continua funcionando sem conhecer novos campos.
+- Conflito Blazor vs SHOC: **SHOC vence**; Blazor não deve escrever campos board após go-live Fase 1.
+- Smoke test EF obrigatório pós-migration (ver checklist smoke).
+
+---
+
+## 4. Política Vendor Portal
+
+- Dispatch intacto; zero regressão checklist/signoff/verify.
+- Vendor não muta WorkOrder core — apenas Dispatch e comments associados.
+- Audit EventType = `Vendor` para mutações portal.
+
+---
+
+## 5. Política Sync/Lambda
+
+- Upsert por `ExternalWorkOrderId` (idempotente).
+- Field-level merge conforme Field Ownership Matrix.
+- Campo com ManualEditFlag → skip + audit `SyncRejected`.
+- Cutover Lambda → API direta: Fase 7.
+
+---
+
+## 6. Regras de conflito (resumo)
+
+| Cenário | Vencedor |
+|---------|----------|
+| SHOC vs SHOC (mesmo campo) | 409 RowVersion; último commit válido |
+| SHOC vs Sync (mesmo campo) | SHOC se ManualEditFlag |
+| SHOC vs Sync (campos distintos) | Merge |
+| Vendor vs Sync | Domínios separados |
+| SHOC vs Vendor (mesmo conceito) | Impossível por design (vendor = Dispatch) |
+| Blazor vs SHOC | SHOC vence; Blazor congelado |
+
+---
+
+## 7. Critérios de aceite
+
+- [ ] Matriz por ator revisada por CTO
+- [ ] PO confirma política Blazor sunset
+- [ ] Sync merge referencia Field Ownership Matrix
+
+**Assinatura CTO:** _________________ Data: _______
diff --git a/docs/work-orders/phase-0/database-drift-report.md b/docs/work-orders/phase-0/database-drift-report.md
new file mode 100644
index 0000000..8d3ce76
--- /dev/null
+++ b/docs/work-orders/phase-0/database-drift-report.md
@@ -0,0 +1,110 @@
+# Database Drift Report — SQL vs EF
+
+**Fase:** 0  
+**Data:** 2026-06-24  
+**EF Snapshot:** `Data.SeaHavenIndustries/Migrations/ApplicationDbContextModelSnapshot.cs`  
+**Script legado:** `Api.SeaHavenIndustries/db.txt`
+
+---
+
+## 1. Metodologia
+
+1. Colunas EF extraídas do `ApplicationDbContextModelSnapshot` (entidade `WorkOrder`).
+2. Colunas SQL legado extraídas de `db.txt` DDL `[WorkOrders]`.
+3. Classificação: **mapear**, **deprecar**, **satélite**, **OK**.
+
+---
+
+## 2. Tabela workOrders — drift conhecido
+
+| Coluna SQL (legado) | No EF? | Classificação | Ação Fase 0 |
+|---------------------|--------|---------------|-------------|
+| WorkOrderType | **Não** | mapear | Adicionar `WorkOrderType` int nullable → enum |
+| AvettaTask | **Não** | inventariar | Adicionar coluna nullable; uso TBD com PO |
+| AssignDate | **Não** | inventariar | Adicionar coluna nullable; possível alias AssignDate tracking |
+| Nome tabela WorkOrders vs workOrders | EF usa `workOrders` | OK | Manter EF naming; SQL Server case-insensitive |
+
+---
+
+## 3. Colunas EF (workOrders) — baseline
+
+Presentes no snapshot e mapeadas:
+
+InternalWONumber, ExternalWorkOrderId, WorkerOrderNumber, WorkerOrderTitle, Description, Customer, SiteCode, Building, Severity, DateReported, ScheduledStart, ScheduledDate, CompletedDate, Source, SourceEmailS3Key, Problem, Trade, SubTrade, VendorNTE, AssignTo, DueDate, Priority, Status, LocationId, PO, TT, Attachments, BeforPhoto*, AfterPhoto*, SignOff*, istemplate, audit fields (CreatedDate, IsDeleted, etc.)
+
+---
+
+## 4. Novas colunas Fase 0 (migration)
+
+| Coluna | Tipo | Slice |
+|--------|------|-------|
+| LifecycleStatus | int nullable | Core |
+| LegacyStatus | nvarchar (cópia Status) | Core |
+| WorkOrderType | int nullable | Core |
+| PrimaryDispatchId | int nullable FK | Core |
+| RowVersion | rowversion | Core |
+| TargetWeek | date nullable | Scheduling |
+| ScheduledEnd | datetime2 nullable | Scheduling |
+| ScheduleWeekOnly | bit nullable | Scheduling |
+| OriginalWeek | date nullable | Tracking |
+| OriginalDate | date nullable | Tracking |
+| RescheduleCount | int default 0 | Analytics |
+| CarriedOver | int default 0 | Analytics |
+| DocStatus | int nullable | Completion |
+| AvettaTask | nvarchar max nullable | Legado SQL |
+| AssignDate | date nullable | Legado SQL |
+
+---
+
+## 5. Dispatch
+
+| Item | EF | Ação Fase 0 |
+|------|-----|-------------|
+| RowVersion | Ausente | Adicionar |
+| Demais colunas | OK | Manter |
+
+---
+
+## 6. WorkOrderAuditLog
+
+| Coluna | EF atual | Ação Fase 0 |
+|--------|----------|-------------|
+| EventType | Ausente | Adicionar |
+| ActorType | Ausente | Adicionar |
+| DispatchId | Ausente | Adicionar nullable |
+| CorrelationId | Ausente | Adicionar nullable |
+
+---
+
+## 7. WorkOrderContacts
+
+| Coluna | EF | Ação Fase 0 |
+|--------|-----|-------------|
+| Notes | Ausente | Adicionar nvarchar nullable (pocNotes) |
+
+---
+
+## 8. ApplicationUser (AspNetUsers)
+
+| Coluna | Ação Fase 0 |
+|--------|-------------|
+| Initials | nvarchar(8) nullable |
+| Color | nvarchar(16) nullable |
+
+---
+
+## 9. Tabelas revisadas — sem drift crítico adicional
+
+- `Comments` — OK
+- `Locations` — OK (SiteCode via WO.SiteCode)
+- `DispatchWorkOrders` — OK
+
+---
+
+## 10. Recomendações
+
+1. **Eliminar dual-path:** `db.txt` catch-up não deve ser usado após migration EF Phase0; documentar em runbook.
+2. **WorkOrderType:** mapear valores SQL existentes → enum na migration data script (dry-run).
+3. **AvettaTask / AssignDate:** manter nullable; PO valida uso antes de exposição board.
+
+**Gate:** Diff assinado por Backend antes de merge migration.
diff --git a/docs/work-orders/phase-0/field-ownership-matrix.md b/docs/work-orders/phase-0/field-ownership-matrix.md
new file mode 100644
index 0000000..7bfe7f7
--- /dev/null
+++ b/docs/work-orders/phase-0/field-ownership-matrix.md
@@ -0,0 +1,86 @@
+# Field Ownership Matrix — Work Orders
+
+**Fase:** 0  
+**Depende de:** [data-ownership-model.md](data-ownership-model.md)  
+**Status:** Draft para sign-off CTO + PO
+
+---
+
+## Legenda
+
+- **Owner escritor:** ator autorizado a criar/alterar o valor canônico.
+- **Sync sobrescreve?:** se ingest DynamoDB pode substituir após WO existir.
+- **ManualEditFlag:** primeira edição SHOC bloqueia Sync no campo (ver [manual-edit-flag-design.md](manual-edit-flag-design.md)).
+
+---
+
+## Matriz completa
+
+| Campo | Agregado | Owner escritor | Sync sobrescreve? | Conflito SHOC vs Sync |
+|-------|----------|----------------|-------------------|----------------------|
+| LifecycleStatus | Core | SHOC | Não após 1ª edição SHOC | SHOC vence |
+| LegacyStatus | Core | — (read-only) | Não | N/A |
+| AssignTo | Core | SHOC | Não após ManualEditFlag | SHOC vence |
+| ScheduledDate | Scheduling | SHOC | Não | SHOC vence |
+| ScheduledStart | Scheduling | SHOC | Parcial (ingest inicial) | SHOC após flag |
+| ScheduledEnd | Scheduling | SHOC | Não | SHOC vence |
+| TargetWeek | Scheduling | SHOC | Não | SHOC vence |
+| ScheduleWeekOnly | Scheduling | SHOC | Não | SHOC vence |
+| DueDate | Core | SHOC + Sync | Sim se nunca editado SHOC | SHOC se ManualEditFlag |
+| Description | Core | SHOC + Sync | Sim se nunca editado SHOC | SHOC se ManualEditFlag |
+| WorkerOrderTitle | Core | SHOC + Sync | Sim se nunca editado SHOC | SHOC se ManualEditFlag |
+| SiteCode | Core | SHOC + Sync | Sim na criação; não após SHOC | SHOC após flag |
+| Building | Core | SHOC + Sync | Sim na criação | SHOC após flag |
+| LocationId | Core | SHOC + Sync | Sim na criação | SHOC após flag |
+| WorkOrderType | Core | SHOC + Sync | Sim na criação ingest | SHOC após flag |
+| InternalWONumber / WoNumber | Core | SHOC (Sync só na criação) | Não | SHOC only |
+| ExternalWorkOrderId | Core | Sync | Sim (idempotente key) | Sync only |
+| VendorId / VendorName | Dispatch | SHOC + Vendor | Não | Domínios separados |
+| Dispatch Status | Dispatch | Vendor + SHOC | Não | Por contexto |
+| Checklist / Signoff | Dispatch | Vendor | Não | Vendor vence |
+| DocStatus | Completion | SHOC | Não | SHOC only |
+| RescheduleCount | Analytics | Domain events | Não | N/A |
+| CarriedOver | Analytics | Jobs (WeekRolled) | Não | N/A |
+| OriginalWeek / OriginalDate | Tracking | SHOC (set-once) | Não | SHOC vence |
+| POC / WorkOrderContacts.Notes | Contacts | SHOC | Não | SHOC vence |
+| Priority / Severity | Core | SHOC + Sync | Sim se nunca editado | SHOC após flag |
+| Status (legado string) | Core | — (deprecated write) | Não | Migrar para LifecycleStatus |
+| Trade / Problem / SubTrade | Core | SHOC | Parcial Sync ingest | SHOC após flag |
+| Customer / Source | Core | Sync + SHOC | Sim na criação | SHOC após flag |
+| Attachments / Photos | Core | SHOC + Vendor | Não overwrite mútuo | Por domínio |
+
+---
+
+## Campos board (14 colunas) — ownership resumido
+
+| Coluna board | Fonte | Owner |
+|--------------|-------|-------|
+| WO# | Core.InternalWONumber | SHOC |
+| Type | Core.WorkOrderType | SHOC |
+| Site | Core.SiteCode | SHOC |
+| Status | Core.LifecycleStatus | SHOC |
+| Assignee | Core.AssignTo | SHOC |
+| Due | Core.DueDate | SHOC + Sync |
+| Scheduled | Scheduling.ScheduledDate | SHOC |
+| Vendor | Dispatch (primário) | SHOC via Dispatch |
+| Appt | Dispatch.ScheduledDate | Dispatch |
+| Past Due | Derivado | — |
+| Carried | Analytics.CarriedOver | Jobs |
+| Reschedule | Analytics.RescheduleCount | Domain |
+| Doc | Completion.DocStatus | SHOC |
+| Actions | — | SHOC UI |
+
+---
+
+## Critérios de aceite
+
+- [ ] PO valida campos board vs matriz
+- [ ] Sync merge implementado referencia esta matriz
+- [ ] ManualEditFlag design aprovado
+
+**Assinaturas**
+
+| Papel | Data |
+|-------|------|
+| CTO | |
+| PO | |
diff --git a/docs/work-orders/phase-0/manual-edit-flag-design.md b/docs/work-orders/phase-0/manual-edit-flag-design.md
new file mode 100644
index 0000000..548727f
--- /dev/null
+++ b/docs/work-orders/phase-0/manual-edit-flag-design.md
@@ -0,0 +1,87 @@
+# ManualEditFlag — Design
+
+**Fase:** 0  
+**Implementação:** tabela satélite `WorkOrderFieldLocks`
+
+---
+
+## 1. Problema
+
+Sync/Lambda faz upsert overwrite em campos que dispatchers editam no SHOC. Precisamos saber, por campo, se houve edição manual SHOC para rejeitar ingest conflitante.
+
+---
+
+## 2. Solução escolhida: tabela satélite
+
+```text
+WorkOrderFieldLocks
+  Id (PK)
+  WorkOrderId (FK)
+  FieldName (string, max 64)
+  LockedAt (UTC)
+  LockedByUserId (nullable — null = system/bootstrap)
+  UNIQUE (WorkOrderId, FieldName)
+```
+
+**Alternativa descartada:** bitmask — difícil de auditar e estender.
+
+---
+
+## 3. Comportamento
+
+| Evento | Ação |
+|--------|------|
+| SHOC edita campo X pela 1ª vez | INSERT lock (WorkOrderId, FieldName) |
+| Sync tenta atualizar campo X com lock | Skip update; audit `SyncRejected` |
+| Sync atualiza campo Y sem lock | Apply merge normal |
+| WO novo (Sync create) | Sem locks; full ingest |
+| Blazor edita campo legado | **Não** cria lock Fase 0 (gap conhecido; Blazor congelado) |
+
+---
+
+## 4. Campos elegíveis a lock (SHOC writers)
+
+Definidos em `SyncFieldMergePolicy.ShocOwnedFields`:
+
+- LifecycleStatus, AssignTo, ScheduledDate, ScheduledEnd, TargetWeek, ScheduleWeekOnly
+- DueDate, Description, WorkerOrderTitle, SiteCode, Building, LocationId
+- WorkOrderType, DocStatus, Trade, Problem, Priority, InternalWONumber
+
+---
+
+## 5. Audit em rejeição
+
+```json
+{
+  "eventType": "Sync",
+  "action": "SyncRejected",
+  "fieldName": "DueDate",
+  "oldValue": "2026-06-01",
+  "newValue": "2026-06-15",
+  "actorType": "Sync"
+}
+```
+
+---
+
+## 6. API interna
+
+```csharp
+interface IWorkOrderFieldLockService
+{
+    Task LockFieldAsync(int workOrderId, string fieldName, string? userId);
+    Task<bool> IsLockedAsync(int workOrderId, string fieldName);
+}
+```
+
+Implementação: `WorkOrderFieldLockService` em `SeaHaven.Services`.
+
+Lock criado automaticamente por `IWorkOrderAuditService` em eventos `Manual` + `FieldChanged` / `StatusChanged`.
+
+---
+
+## 7. Critérios de aceite
+
+- [ ] Tabela criada na migration Phase0
+- [ ] Sync consulta locks antes de overwrite
+- [ ] SyncRejected aparece no audit log
diff --git a/docs/work-orders/phase-0/migration-dry-run-report.md b/docs/work-orders/phase-0/migration-dry-run-report.md
new file mode 100644
index 0000000..2a815e0
--- /dev/null
+++ b/docs/work-orders/phase-0/migration-dry-run-report.md
@@ -0,0 +1,58 @@
+# Migration Dry-Run Report — Phase 0
+
+**Migration:** `20260624163145_Phase0_DomainFoundation`  
+**Status:** Pronto para execução em staging
+
+---
+
+## 1. Procedimento
+
+1. Restore backup produção → staging espelho
+2. Snapshot pré-migration:
+   ```sql
+   SELECT Status, COUNT(*) FROM workOrders GROUP BY Status;
+   SELECT COUNT(*) AS Total FROM workOrders;
+   ```
+3. Executar:
+   ```powershell
+   dotnet ef database update --project Data.SeaHavenIndustries --startup-project Api.SeaHavenIndustries
+   ```
+4. Validar pós-migration:
+   ```sql
+   SELECT COUNT(*) FROM workOrders WHERE LegacyStatus IS NOT NULL;
+   SELECT LifecycleStatus, COUNT(*) FROM workOrders GROUP BY LifecycleStatus;
+   SELECT COUNT(*) FROM workOrders WHERE PrimaryDispatchId IS NOT NULL;
+   ```
+5. Smoke Blazor + API legado + Sync sample
+6. Rollback (se falha):
+   ```powershell
+   dotnet ef database update 20260417195316_AddDispatchVerification --project Data.SeaHavenIndustries --startup-project Api.SeaHavenIndustries
+   ```
+
+---
+
+## 2. Data scripts incluídos na migration
+
+- `LegacyStatus` ← cópia de `Status`
+- `LifecycleStatus` ← mapeamento legado (Open→Incomplete, etc.)
+- `PrimaryDispatchId` ← dispatch mais recente por WO
+
+---
+
+## 3. Resultados (preencher em staging)
+
+| Métrica | Antes | Depois |
+|---------|-------|--------|
+| Total WOs | | |
+| Com LegacyStatus | | |
+| Com LifecycleStatus | | |
+| Com PrimaryDispatchId | | |
+| Rollback testado | | Sim/Não |
+
+---
+
+## 4. Notas
+
+A migration inclui reconciliação de drift em `Locations`, `Regions`, `Departments` detectada pelo EF — revisar impacto em staging antes de produção.
+
+**WO# normalização 11 dígitos:** documentada para Fase 2; não executada nesta migration.
diff --git a/docs/work-orders/phase-0/phase-0-gates-signoff.md b/docs/work-orders/phase-0/phase-0-gates-signoff.md
new file mode 100644
index 0000000..ddc4199
--- /dev/null
+++ b/docs/work-orders/phase-0/phase-0-gates-signoff.md
@@ -0,0 +1,46 @@
+# Phase 0 — Gates Sign-Off Checklist
+
+**Programa:** Work Orders Board  
+**Fase:** 0 — Domain Foundation + Governança
+
+---
+
+## 9 Gates bloqueantes
+
+| # | Gate | Artefato | Status |
+|---|------|----------|--------|
+| 1 | DAR aprovado | [dar-domain-architecture-review.md](dar-domain-architecture-review.md) | Documentado |
+| 2 | Data Ownership Model | [data-ownership-model.md](data-ownership-model.md) | Documentado |
+| 3 | Field Ownership Matrix | [field-ownership-matrix.md](field-ownership-matrix.md) | Documentado |
+| 4 | Audit Event Contract | [audit-event-contract.md](audit-event-contract.md) | Implementado baseline |
+| 5 | Volume Discovery | [volume-discovery-report.md](volume-discovery-report.md) | Queries prontas; tier S provisório |
+| 6 | Database drift | [database-drift-report.md](database-drift-report.md) | Documentado |
+| 7 | Spike vendor/dispatch | [adr-vendor-source-of-truth.md](adr-vendor-source-of-truth.md) | ADR + query |
+| 8 | Migration dry-run | [migration-dry-run-report.md](migration-dry-run-report.md) | Procedimento pronto |
+| 9 | RowVersion multi-agregado | WO + Dispatch + ConcurrencyExceptionFilter | Implementado |
+
+---
+
+## Implementação código (Fase 0)
+
+- Migration `Phase0_DomainFoundation`
+- Enums: LifecycleStatus, WorkOrderType, DocStatus, AuditEventType, etc.
+- `IWorkOrderAuditService`, `IWorkOrderFieldLockService`, `ISyncFieldMergePolicy`
+- `[Authorize]` reativado em WorkOrderController
+- Projeto `SeaHavenIndustries.Tests`
+
+---
+
+## GO Fase 1 — pendente
+
+- [ ] Sign-off CTO/PO nos artefatos
+- [ ] Dry-run staging executado
+- [ ] Volume tier confirmado em staging/prod
+- [ ] Smoke checklist verde
+
+**Assinatura GO Fase 1**
+
+| Papel | Nome | Data |
+|-------|------|------|
+| CTO | | |
+| PO | | |
diff --git a/docs/work-orders/phase-0/rowversion-design.md b/docs/work-orders/phase-0/rowversion-design.md
new file mode 100644
index 0000000..9e80ddc
--- /dev/null
+++ b/docs/work-orders/phase-0/rowversion-design.md
@@ -0,0 +1,36 @@
+# RowVersion Multi-Agregado — Design
+
+**Fase:** 0 — Gate #9
+
+---
+
+## Agregados
+
+| Agregado | Coluna | Comportamento |
+|----------|--------|---------------|
+| WorkOrder | `RowVersion` rowversion | Bump em mutação WO (schedule, status, assignment) |
+| Dispatch | `RowVersion` rowversion | Bump em mutação vendor/checklist/signoff |
+
+---
+
+## HTTP 409
+
+`ConcurrencyExceptionFilter` captura `DbUpdateConcurrencyException` e retorna:
+
+```json
+{
+  "status": "Conflict",
+  "message": "The record was modified by another user. Refresh and retry.",
+  "code": 409
+}
+```
+
+---
+
+## Regras (Fase 2 testes completos)
+
+- SHOC edita ScheduledDate → bump WO.RowVersion
+- SHOC edita vendor → bump Dispatch.RowVersion
+- Vendor edita checklist → bump Dispatch.RowVersion only
+
+Testes de concorrência paralela: Fase 2 (`Concurrency integration tests` backlog #27).
diff --git a/docs/work-orders/phase-0/smoke-checklist.md b/docs/work-orders/phase-0/smoke-checklist.md
new file mode 100644
index 0000000..0bad17e
--- /dev/null
+++ b/docs/work-orders/phase-0/smoke-checklist.md
@@ -0,0 +1,57 @@
+# Smoke Test Checklist — Multi-Consumidor (Fase 0)
+
+**Ambiente:** Docker local (`docker compose up -d` + `scripts/setup-local-db.ps1`)
+
+---
+
+## Blazor EF
+
+| # | Teste | Pass |
+|---|-------|------|
+| 1 | `/workorderlist` carrega sem exception | [ ] |
+| 2 | Abrir detalhe WO existente | [ ] |
+| 3 | Campos novos nullable não quebram binding | [ ] |
+
+---
+
+## API REST (legado)
+
+| # | Teste | Pass |
+|---|-------|------|
+| 1 | POST login → JWT | [ ] |
+| 2 | GET work order list com Bearer token | [ ] |
+| 3 | POST ChangeStatus com audit no log | [ ] |
+| 4 | POST ChangeAssignment.tex Assignment com audit | [ ] |
+| 5 | 401 sem token (auth reativada) | [ ] |
+
+---
+
+## Sync
+
+| # | Teste | Pass |
+|---|-------|------|
+| 1 | POST `api/Sync/WorkOrders` com JWT (mock/staging DynamoDB) | [ ] |
+| 2 | Upsert idempotente por ExternalWorkOrderId | [ ] |
+| 3 | Campo locked → SyncRejected no audit | [ ] |
+
+---
+
+## Vendor Portal
+
+| # | Teste | Pass |
+|---|-------|------|
+| 1 | Checklist update flow | [ ] |
+| 2 | Signoff flow | [ ] |
+| 3 | Dispatch RowVersion presente (schema) | [ ] |
+
+---
+
+## Automação local
+
+```powershell
+dotnet test SeaHavenIndustries.Tests
+dotnet build
+./scripts/setup-local-db.ps1
+```
+
+Testes unitários cobrem: LifecycleStatusMapper, audit baseline, sync merge rejection.
diff --git a/docs/work-orders/phase-0/volume-discovery-report.md b/docs/work-orders/phase-0/volume-discovery-report.md
new file mode 100644
index 0000000..12c48c3
--- /dev/null
+++ b/docs/work-orders/phase-0/volume-discovery-report.md
@@ -0,0 +1,96 @@
+# Volume Discovery Report — Work Orders
+
+**Fase:** 0 — Gate Fase 1  
+**Data:** 2026-06-24  
+**Ambiente:** Local dev (Docker) + queries para staging/prod
+
+---
+
+## 1. Objetivo
+
+Definir tier S/M/L/XL antes de índices e estratégia de search (Fase 4). **Sem premissa de volume.**
+
+---
+
+## 2. Queries obrigatórias
+
+Executar em staging ou produção read-only:
+
+```sql
+-- Total WOs
+SELECT COUNT(*) AS TotalWorkOrders
+FROM workOrders
+WHERE IsDeleted IS NULL OR IsDeleted = 0;
+
+-- WOs por semana (ISO) — p95
+WITH WeeklyCounts AS (
+    SELECT DATEPART(iso_week, ScheduledDate) AS IsoWeek,
+           YEAR(ScheduledDate) AS IsoYear,
+           COUNT(*) AS Cnt
+    FROM workOrders
+    WHERE ScheduledDate IS NOT NULL
+      AND (IsDeleted IS NULL OR IsDeleted = 0)
+    GROUP BY DATEPART(iso_week, ScheduledDate), YEAR(ScheduledDate)
+)
+SELECT MAX(Cnt) AS P95ProxyMaxPerWeek,
+       AVG(Cnt * 1.0) AS AvgPerWeek
+FROM WeeklyCounts;
+
+-- Unscheduled (não terminal)
+SELECT COUNT(*) AS UnscheduledCount
+FROM workOrders
+WHERE ScheduledDate IS NULL
+  AND (IsDeleted IS NULL OR IsDeleted = 0)
+  AND Status NOT IN ('Completed', 'Complete', 'Cancelled', 'Canceled');
+
+-- Crescimento mensal
+SELECT YEAR(CreatedDate) AS Y, MONTH(CreatedDate) AS M, COUNT(*) AS Cnt
+FROM workOrders
+WHERE CreatedDate IS NOT NULL
+GROUP BY YEAR(CreatedDate), MONTH(CreatedDate)
+ORDER BY Y DESC, M DESC;
+```
+
+---
+
+## 3. Resultados
+
+| Métrica | Local Docker (dev) | Staging | Produção |
+|---------|-------------------|---------|----------|
+| Total WOs | *executar após seed* | _pendente acesso_ | _pendente acesso_ |
+| WOs/semana p95 | — | _pendente_ | _pendente_ |
+| Unscheduled | — | _pendente_ | _pendente_ |
+| Crescimento mensal | — | _pendente_ | _pendente_ |
+
+**Nota:** Ambiente local inicia vazio. Tier provisório para desenvolvimento: **S** (< 25k). Confirmar com query em staging antes do GO Fase 1.
+
+---
+
+## 4. Classificação tier (§10.2 roadmap)
+
+| Tier | Total WOs | Listagem semanal | Advanced search |
+|------|-----------|------------------|-----------------|
+| **S** | < 25k | Índices simples | SQL filtros compostos |
+| **M** | 25k–250k | Índices covering | Paginação obrigatória |
+| **L** | 250k–1M | Read model candidato | Full-text |
+| **XL** | > 1M | Materialized view | Search dedicado (ARB) |
+
+**Tier definido para Fase 1:** **S (provisório dev)** — revisar ao obter métricas staging.
+
+---
+
+## 5. Impacto Fase 0–1
+
+- Fases 1–3: índices conservadores compatíveis com qualquer tier.
+- Fase 4: implementação search conforme tier confirmado + load test.
+
+---
+
+## 6. Script local
+
+```powershell
+./scripts/setup-local-db.ps1
+# Executar queries acima via sqlcmd ou DBCode contra localhost:1433
+```
+
+**Gate:** Preencher coluna Staging/Produção antes do GO Fase 1.
diff --git a/docs/work-orders/phase-1/README.md b/docs/work-orders/phase-1/README.md
new file mode 100644
index 0000000..5442c49
--- /dev/null
+++ b/docs/work-orders/phase-1/README.md
@@ -0,0 +1,155 @@
+# Fase 1 — Weekly Board (leitura)
+
+**Programa:** Work Orders Board  
+**Objetivo:** Endpoint window-based para carregar a visão semanal do SHOC (Mon–Fri + Unscheduled) com projeção das 14 colunas operacionais.
+
+---
+
+## Endpoints
+
+### `GET /api/workorders/board`
+
+Retorna WOs agendadas na semana + seção **Unscheduled** em uma única chamada.
+
+**Autenticação:** Bearer JWT (`[Authorize]`)
+
+**Query params:**
+
+| Param | Obrigatório | Descrição |
+|-------|-------------|-----------|
+| `weekStart` | Sim | Segunda-feira da semana (`YYYY-MM-DD`) |
+| `weekEnd` | Não | Sexta-feira (default: `weekStart + 4 dias`) |
+| `dispatchers` | Não | Lista de GUIDs; use `__unassigned__` para não atribuídos |
+| `myWorkOrders` | Não | `true` → filtra `AssignTo == usuário logado` |
+| `types` | Não | Valores enum `WorkOrderType` (`PM`, `PO`, `Emergency`, etc.) |
+| `search` | Não | Busca contextual (site, WO#, location, dispatcher, trade, vendor, status) |
+
+**Exemplo:**
+
+```bash
+curl -H "Authorization: Bearer <token>" \
+  "https://localhost:5001/api/workorders/board?weekStart=2026-06-22&myWorkOrders=true"
+```
+
+**Response:**
+
+```json
+{
+  "weekStart": "2026-06-22",
+  "weekEnd": "2026-06-26",
+  "counts": { "returned": 42, "total": 58 },
+  "unscheduled": [ /* WorkOrderBoardRowDto[] */ ],
+  "scheduled": [ /* WorkOrderBoardRowDto[] — agrupar por dayGroup no FE */ ]
+}
+```
+
+- `counts.total` — WOs agendadas na semana (filtros dispatcher/tipo, **sem** search)
+- `counts.returned` — WOs agendadas após aplicar search
+
+### `GET /api/workorders/lookups/dispatchers`
+
+Lista dispatchers para filtros do board.
+
+```json
+[
+  { "id": "guid", "name": "Jane Doe", "initials": "JD", "color": "#4A90D9" }
+]
+```
+
+---
+
+## Matriz coluna → campo API
+
+| Coluna board | Campos response |
+|--------------|-----------------|
+| WO# | `woNumber`, `rescheduleCount`, `carriedOver` |
+| Type | `workOrderType`, `isPastDue` |
+| Site | `siteCode`, `locationName`, `pocName`, `pocPhone`, `pocNotes` |
+| Status | `lifecycleStatus`, `lifecycleStatusLabel`, `legacyStatus` |
+| Assignee | `dispatcherId`, `dispatcherName`, `initials`, `color` |
+| Due | `dueDate` |
+| Scheduled | `scheduledDate`, `targetWeek`, `scheduleWeekOnly`, `dayGroup` |
+| Vendor | `vendorId`, `vendorName`, `techName`, `techPhone` |
+| Appt | `apptDate`, `apptTime` |
+| Past Due | `isPastDue` (derivado on-read) |
+| Carried | `carriedOver` |
+| Reschedule | `rescheduleCount` |
+| Doc | `docStatus` |
+| Actions | FE only |
+
+---
+
+## Regras de derivação
+
+### isPastDue
+
+```
+ScheduledDate < UTC hoje
+AND LifecycleStatus NOT IN (Complete, Canceled, Closed)
+```
+
+Implementação: `SeaHaven.Services/Helpers/WorkOrderDerivedFields.cs`
+
+### Vendor / Appt
+
+Projeção read-only via `WorkOrder.PrimaryDispatchId` → `Dispatch` → `Vendor` ([ADR](../phase-0/adr-vendor-source-of-truth.md)).
+
+### Janela semanal
+
+WO entra em **scheduled** se:
+
+- `ScheduledDate` entre `weekStart` e `weekEnd`, **ou**
+- `ScheduleWeekOnly == true` e `TargetWeek == weekStart`
+
+**Unscheduled:** `ScheduledDate == null` e status não terminal.
+
+---
+
+## Código entregue
+
+| Camada | Arquivo |
+|--------|---------|
+| DTOs | `SeaHaven.Services/DTOs/WorkOrderBoardDTOs.cs` |
+| Derived fields | `SeaHaven.Services/Helpers/WorkOrderDerivedFields.cs` |
+| Data | `SeaHaven.DataServices/Implementation/WorkOrderBoardDataService.cs` |
+| Service | `SeaHaven.Services/Implementation/WorkOrderBoardService.cs` |
+| API | `Api.SeaHavenIndustries/Controllers/WorkOrderController.cs` (`board`, `lookups/dispatchers`) |
+| Migration | `Data.SeaHavenIndustries/Migrations/20260624180343_Phase1_BoardIndexes.cs` |
+| Testes | `SeaHavenIndustries.Tests/WorkOrderDerivedFieldsTests.cs`, `WorkOrderBoardServiceTests.cs` |
+
+---
+
+## Gates de aceite
+
+### Desenvolvimento (concluído)
+
+- [x] Endpoint `GET board` — semana + Unscheduled
+- [x] Projeção 12/14 colunas de dados
+- [x] `isPastDue` derivado on-read
+- [x] Vendor via dispatch primário
+- [x] Filtros dispatcher / My WOs / tipo / search
+- [x] Contador X of Y
+- [x] Índices Tier S
+- [x] 14 testes unitários board (+ 12 Fase 0 = 26 total)
+
+### Staging / produção (pendente)
+
+- [ ] Sign-off CTO/PO (herda gates Fase 0)
+- [ ] Dry-run migration Phase0 + Phase1 em staging
+- [ ] Tier volume confirmado em staging/prod
+- [ ] Smoke checklist Blazor / Sync / Portal
+- [ ] Gate Vendor Portal regression (endpoints dispatch inalterados)
+- [ ] Latência aceitável com volume real (Tier S: &lt; 25k WOs)
+- [ ] Feature flag SHOC board em staging
+
+---
+
+## Coexistência
+
+Endpoints legados (`GetWorkOrderList`, `GetWorkorderById`, etc.) **não foram alterados**. O board usa contrato novo em rotas separadas.
+
+---
+
+## Próximo passo
+
+**Fase 2** — Inline edit + concorrência (dual RowVersion, audit por campo, PATCH granular).
diff --git a/docs/work-orders/phase-2/README.md b/docs/work-orders/phase-2/README.md
new file mode 100644
index 0000000..584e8ad
--- /dev/null
+++ b/docs/work-orders/phase-2/README.md
@@ -0,0 +1,154 @@
+# Fase 2 — Inline Edit + Concorrência
+
+**Programa:** Work Orders Board  
+**Objetivo:** Edição spreadsheet-style célula a célula no board SHOC, com dual RowVersion, audit granular e regras de domínio no backend.
+
+**Depende de:** [Fase 0](../phase-0/README.md), [Fase 1](../phase-1/README.md)
+
+---
+
+## Endpoints
+
+### `PATCH /api/workorders/{id}/board`
+
+Atualiza um único campo do board com validação otimista de concorrência.
+
+**Autenticação:** Bearer JWT (`[Authorize]`)
+
+**Request body:**
+
+```json
+{
+  "field": "scheduledDate",
+  "value": "2026-06-25",
+  "workOrderVersion": "<base64 RowVersion>",
+  "dispatchVersion": "<base64 RowVersion | null para campos WO-only>",
+  "primaryDispatchId": 123
+}
+```
+
+| Campo | Obrigatório | Descrição |
+|-------|-------------|-----------|
+| `field` | Sim | Nome canônico do campo (case-insensitive) |
+| `value` | Sim* | Valor serializado como string (*pode ser vazio para limpar datas) |
+| `workOrderVersion` | Sim | `RowVersion` atual da WO (Base64) |
+| `dispatchVersion` | Condicional | Obrigatório para campos Dispatch quando dispatch já existe |
+| `primaryDispatchId` | Não | Valida que o dispatch pertence à WO |
+
+**Responses:**
+
+| HTTP | Body | Quando |
+|------|------|--------|
+| 200 | `WorkOrderBoardRowDto` | Sucesso — row completo com versões atualizadas |
+| 409 | `WorkOrderBoardConflictDto` + `currentState` | Conflito de versão |
+| 422 | `WorkOrderBoardValidationErrorDto` | Regra de domínio violada |
+| 400 | `Response` | Erro genérico / argumento inválido |
+
+**Exemplo:**
+
+```bash
+curl -X PATCH -H "Authorization: Bearer <token>" \
+  -H "Content-Type: application/json" \
+  -d '{"field":"siteCode","value":"BK5","workOrderVersion":"AQAAAAAAAAA="}' \
+  "https://localhost:5001/api/workorders/1/board"
+```
+
+---
+
+## Campos editáveis
+
+| field (API) | Agregado | Coluna board | Audit FieldName |
+|-------------|----------|--------------|-----------------|
+| `woNumber` | WorkOrder | WO# | InternalWONumber |
+| `workOrderType` | WorkOrder | Type | WorkOrderType |
+| `siteCode` | WorkOrder | Site | SiteCode |
+| `lifecycleStatus` | WorkOrder | Status | LifecycleStatus |
+| `assignTo` | WorkOrder | Assignee | AssignTo |
+| `dueDate` | WorkOrder | Due | DueDate |
+| `scheduledDate` | WorkOrder | Scheduled | ScheduledDate |
+| `targetWeek` | WorkOrder | Scheduled (week-only) | TargetWeek |
+| `scheduleWeekOnly` | WorkOrder | Scheduled | ScheduleWeekOnly |
+| `vendorId` | Dispatch | Vendor | VendorId |
+| `apptDate` | Dispatch | Appt | ApptDate |
+| `apptTime` | Dispatch/WO | Appt | ApptTime |
+| `docStatus` | WorkOrder | Doc | DocStatus |
+
+**Read-only:** `isPastDue`, `carriedOver`, `rescheduleCount` (badge derivado; count incrementado por regra).
+
+---
+
+## Dual RowVersion
+
+| Agregado | Quando exigir versão |
+|----------|---------------------|
+| WorkOrder | Sempre (`workOrderVersion`) |
+| Dispatch | Campos vendor/appt quando dispatch primário já existe (`dispatchVersion`) |
+
+O GET board retorna `rowVersion`, `dispatchRowVersion` e `primaryDispatchId` em cada row.
+
+**409 currentState:** inclui row recarregado do DB para refresh imediato no FE.
+
+---
+
+## Regras de domínio
+
+| Regra | Comportamento |
+|-------|---------------|
+| Auto-schedule | `Incomplete` + `scheduledDate` + `assignTo` → `Scheduled` |
+| Reschedule | Mudança de `scheduledDate` com data anterior → `rescheduleCount++` |
+| Set-once tracking | Primeira `scheduledDate` → `OriginalDate` / `OriginalWeek` |
+| Past Due block | Não permite mudar `lifecycleStatus` quando `isPastDue` |
+| Cancel read-only | Status terminal (`Canceled`, `Closed`, `Complete`) bloqueia PATCH |
+| WO# 11 dígitos | Normalização numérica + unicidade |
+| Vendor ADR | Mutação em `Dispatch`; cria dispatch primário se ausente |
+
+---
+
+## Audit
+
+- 1 evento por campo alterado (`FieldChanged`, `StatusChanged`, ou `AssignmentChanged`)
+- Side effects (auto-schedule, rescheduleCount) geram eventos adicionais
+- Field lock (`WorkOrderFieldLocks`) criado automaticamente em edições manuais
+- Eventos Dispatch incluem `dispatchId`
+
+---
+
+## Código entregue
+
+| Camada | Arquivo |
+|--------|---------|
+| DTOs | `SeaHaven.Services/DTOs/WorkOrderBoardDTOs.cs` |
+| Helpers | `WorkOrderBoardMutationRules`, `WorkOrderNumberNormalizer`, `WorkOrderBoardFieldNames`, `WorkOrderBoardApptTimeParser` |
+| Update service | `SeaHaven.Services/Implementation/WorkOrderBoardUpdateService.cs` |
+| Audit | `IWorkOrderAuditService.StageFieldChanged`, `LogFieldChangedAsync` |
+| API | `WorkOrderController` — `PATCH {id}/board` |
+| Testes | `WorkOrderBoardMutationRulesTests`, `WorkOrderNumberNormalizerTests`, `WorkOrderBoardUpdateServiceTests`, `WorkOrderBoardConcurrencyTests` |
+
+---
+
+## Gates de aceite
+
+### Desenvolvimento
+
+- [x] `PATCH /api/workorders/{id}/board` para todos os campos da matriz
+- [x] Dual RowVersion validado; 409 com `currentState`
+- [x] Auto-schedule Incomplete→Scheduled
+- [x] RescheduleCount++ em reagendamento
+- [x] Bloqueio status quando PastDue; reagendar limpa flag on-read
+- [x] WO cancelado/closed rejeita edição (422)
+- [x] WO# normalizado 11 dígitos + unicidade
+- [x] Vendor/appt muta Dispatch; cria primário se ausente
+- [x] 1 audit event por campo; field lock criado
+- [x] 51 testes unitários total (25 Fase 2 + 26 Fases 0–1)
+
+### Staging (pendente)
+
+- [ ] Smoke Sync durante edição SHOC
+- [ ] UAT dispatcher: editar células reais no board
+- [ ] Latência PATCH aceitável (<200ms p95 Tier S)
+
+---
+
+## Próximo passo
+
+**Fase 3** — Criação wizard/inline, soft cancel dedicado, ManualEditFlag na criação.
diff --git a/docs/work-orders/phase-3/README.md b/docs/work-orders/phase-3/README.md
new file mode 100644
index 0000000..1e09aed
--- /dev/null
+++ b/docs/work-orders/phase-3/README.md
@@ -0,0 +1,174 @@
+# Fase 3 — Criação e Cancelamento
+
+**Programa:** Work Orders Board  
+**Objetivo:** Criação wizard/inline via contrato do board SHOC, cancelamento soft dedicado, ManualEditFlag na criação, e delete físico restrito a Admin.
+
+**Depende de:** [Fase 0](../phase-0/README.md), [Fase 1](../phase-1/README.md), [Fase 2](../phase-2/README.md)
+
+---
+
+## Endpoints
+
+### `POST /api/workorders/board`
+
+Cria uma WO com contrato alinhado ao board. Suporta wizard (payload completo) e inline row (subset mínimo).
+
+**Autenticação:** Bearer JWT (`[Authorize]`)
+
+**Request body:**
+
+```json
+{
+  "woNumber": "12345",
+  "workOrderType": "PM",
+  "siteCode": "BK5",
+  "assignTo": "dispatcher-guid",
+  "dueDate": "2026-07-01",
+  "scheduledDate": "2026-06-25",
+  "targetWeek": "2026-06-22",
+  "scheduleWeekOnly": false,
+  "vendorId": 5,
+  "apptDate": "2026-06-26",
+  "apptTime": "09:00 – 11:00",
+  "docStatus": "No",
+  "description": "Leak in break room",
+  "trade": "HVAC PM",
+  "locationId": 12,
+  "pocContactId": 3,
+  "pocNotes": "Call before arrival"
+}
+```
+
+| Campo | Obrigatório | Descrição |
+|-------|-------------|-----------|
+| `workOrderType` | Sim | Enum `WorkOrderType` |
+| `siteCode` | Sim | Código do site |
+| `woNumber` | Não | Se omitido, auto-gera sequencial normalizado 11 dígitos |
+| `scheduleWeekOnly` | Não | Se `true`, `targetWeek` é obrigatório |
+| `vendorId` | Condicional | Obrigatório quando `apptDate` ou `apptTime` informados |
+
+**Responses:**
+
+| HTTP | Body | Quando |
+|------|------|--------|
+| 200 | `WorkOrderBoardRowDto` | Sucesso — row pronto para inserir no board |
+| 400 | `Response` | Validação FluentValidation |
+| 409 | `WorkOrderBoardValidationErrorDto` | WO# duplicado |
+| 422 | `WorkOrderBoardValidationErrorDto` | Regra de domínio |
+
+**Exemplo (inline mínimo):**
+
+```bash
+curl -X POST -H "Authorization: Bearer <token>" \
+  -H "Content-Type: application/json" \
+  -d '{"workOrderType":"PM","siteCode":"BK5"}' \
+  "https://localhost:5001/api/workorders/board"
+```
+
+---
+
+### `POST /api/workorders/{id}/cancel`
+
+Soft cancel — transição para `LifecycleStatus.Canceled` com WO read-only.
+
+**Autenticação:** Bearer JWT
+
+**Responses:**
+
+| HTTP | Body | Quando |
+|------|------|--------|
+| 200 | `WorkOrderBoardRowDto` | Cancelado (ou já estava cancelado — idempotente) |
+| 422 | `WorkOrderBoardValidationErrorDto` | WO `Complete` ou `Closed` |
+
+**Exemplo:**
+
+```bash
+curl -X POST -H "Authorization: Bearer <token>" \
+  "https://localhost:5001/api/workorders/42/cancel"
+```
+
+---
+
+## Regras de domínio na criação
+
+| Regra | Comportamento |
+|-------|---------------|
+| Status inicial | `Incomplete` |
+| Auto-schedule | `scheduledDate` + `assignTo` → `Scheduled` |
+| Set-once tracking | Primeira `scheduledDate` → `OriginalDate` / `OriginalWeek` |
+| Week-only | `scheduleWeekOnly=true` + `targetWeek` → aparece na semana no GET board |
+| WO# | Manual normalizado 11 dígitos; auto-gerado se omitido |
+| Vendor | Cria dispatch primário quando `vendorId` informado |
+| ManualEditFlag | Field locks criados para cada campo SHOC preenchido |
+
+---
+
+## Soft cancel vs hard delete
+
+| Operação | Endpoint | Quem | Efeito |
+|----------|----------|------|--------|
+| Soft cancel | `POST /{id}/cancel` | Dispatcher | Status `Canceled`, WO permanece, PATCH bloqueado (422) |
+| Hard delete | `DELETE DeleteWorkorder` | **Admin only** | Remove registro, anexos e contatos |
+
+O legado `POST AddWorkorder` (form/Blazor) permanece inalterado.
+
+---
+
+## ManualEditFlag na criação
+
+Campos preenchidos na criação SHOC recebem lock em `WorkOrderFieldLocks` via audit `FieldChanged`. Sync subsequente em campo lockado gera `SyncRejected` (ver [manual-edit-flag-design.md](../phase-0/manual-edit-flag-design.md)).
+
+WO criada via Sync/Lambda continua sem locks até edição SHOC.
+
+---
+
+## Audit
+
+| Evento | Action |
+|--------|--------|
+| Criação | 1× `Create` + `FieldChanged` por campo preenchido |
+| Auto-schedule na criação | `StatusChanged` adicional |
+| Cancel | `StatusChanged` → `Canceled` |
+| Hard delete Admin | `Delete` |
+
+---
+
+## Código entregue
+
+| Camada | Arquivo |
+|--------|---------|
+| DTOs | `SeaHaven.Services/DTOs/WorkOrderBoardDTOs.cs` |
+| Validação | `SeaHaven.Services/Validation/WorkOrderBoardCreateValidation.cs` |
+| Scheduling compartilhado | `SeaHaven.Services/Helpers/WorkOrderBoardFieldMutations.cs` |
+| Create service | `SeaHaven.Services/Implementation/WorkOrderBoardCreateService.cs` |
+| Cancel service | `SeaHaven.Services/Implementation/WorkOrderBoardCancelService.cs` |
+| Audit | `IWorkOrderAuditService.StageCreated`, `LogCreatedAsync` |
+| API | `WorkOrderController` — `POST board`, `POST {id}/cancel`, `DELETE` Admin |
+| Testes | `WorkOrderBoardCreateServiceTests`, `WorkOrderBoardCancelServiceTests`, `WorkOrderBoardCreateSyncLockTests` |
+
+---
+
+## Gates de aceite
+
+### Desenvolvimento
+
+- [x] `POST /api/workorders/board` — Incomplete / auto-schedule / week-only
+- [x] WO# auto ou manual 11 dígitos + unicidade (409)
+- [x] Vendor/dispatch primário na criação
+- [x] Field locks + SyncRejected pós-create SHOC
+- [x] `POST /{id}/cancel` idempotente; PATCH bloqueado após cancel
+- [x] `DELETE DeleteWorkorder` restrito a Admin
+- [x] Legado `AddWorkorder` inalterado
+- [x] 68 testes unitários total (17 Fase 3 + 51 Fases 0–2)
+
+### Staging (pendente)
+
+- [ ] UAT dispatcher: wizard + inline row
+- [ ] Smoke Sync durante criação SHOC
+- [ ] Confirmar navegação FE para semana do WO criado
+
+---
+
+## Próximo passo
+
+**Fase 4** — Busca contextual na semana + advanced search cross-week conforme tier volume.
diff --git a/docs/work-orders/phase-4/README.md b/docs/work-orders/phase-4/README.md
new file mode 100644
index 0000000..d9b602f
--- /dev/null
+++ b/docs/work-orders/phase-4/README.md
@@ -0,0 +1,162 @@
+# Fase 4 — Search contextual + Advanced Search
+
+**Programa:** Work Orders Board  
+**Objetivo:** Hardening da busca contextual no board semanal, endpoint de advanced search cross-week (Tier S), índices de suporte e harness de load test.
+
+**Depende de:** [Fase 0](../phase-0/README.md), [Fase 1](../phase-1/README.md), [Fase 2](../phase-2/README.md), [Fase 3](../phase-3/README.md)
+
+**Tier vigente (dev):** **S (provisório)** — ver [search-tier-decision.md](./search-tier-decision.md)
+
+---
+
+## Endpoints
+
+### `GET /api/workorders/board?search=` (hardening)
+
+Busca contextual na janela semanal. Campos cobertos:
+
+| Campo | Origem |
+|-------|--------|
+| Site | `SiteCode` |
+| WO# | `InternalWONumber`, `WorkerOrderNumber` |
+| Location | `Locations.Name` |
+| Dispatcher | `AssignToUser` nome |
+| PM | `Trade`, `Problem` |
+| Vendor | `PrimaryDispatch.Vendor.CompanyName` |
+| Tech | `PrimaryDispatch.Vendor.ContactName` |
+| Status legado | `Status` |
+| Lifecycle | label enum (`Scheduled`, `In Progress`, etc.) |
+
+**Regras:**
+
+- `search` com trim; ignorado se vazio ou &lt; 2 caracteres
+- `counts.total` — agendadas na semana **sem** search
+- `counts.returned` — agendadas **com** search
+
+### `GET /api/workorders/board/search`
+
+Advanced search cross-week paginado.
+
+**Autenticação:** Bearer JWT
+
+**Query params:**
+
+| Param | Tipo | Descrição |
+|-------|------|-----------|
+| `search` | string | Texto livre (mesmos campos do contextual) |
+| `datePreset` | enum | `thisWeek`, `lastWeek`, `thisMonth`, `last3Months`, `nextWeek`, `nextMonth`, `custom` |
+| `dateFrom` / `dateTo` | date | Obrigatórios se `datePreset=custom` |
+| `sites` | string[] | `SiteCode` |
+| `types` | WorkOrderType[] | Tipo WO |
+| `dispatchers` | string[] | GUIDs + `__unassigned__` |
+| `statuses` | LifecycleStatus[] | Status operacional |
+| `pmTypes` | string[] | Match em `Trade`/`Problem` (contains, case-insensitive) |
+| `vendorIds` | int[] | Via `PrimaryDispatch.VendorId` |
+| `docStatuses` | DocStatus[] | Enum `DocStatus` |
+| `myWorkOrders` | bool | Filtro usuário logado |
+| `page` | int | Default 1 |
+| `pageSize` | int | Default 50; max 100 (Tier S/M) |
+| `sortBy` | string | `scheduledDate` (default), `woNumber`, `dueDate` |
+| `sortDir` | string | `asc` / `desc` |
+
+**Response:** `PagedResult<WorkOrderBoardRowDto>`
+
+```json
+{
+  "items": [ /* WorkOrderBoardRowDto */ ],
+  "totalCount": 120,
+  "page": 1,
+  "pageSize": 50,
+  "totalPages": 3,
+  "hasNext": true,
+  "hasPrevious": false
+}
+```
+
+**Exemplo:**
+
+```bash
+curl -H "Authorization: Bearer <token>" \
+  "https://localhost:5001/api/workorders/board/search?datePreset=thisMonth&sites=BK5&search=HVAC&page=1"
+```
+
+---
+
+## Matriz preset → intervalo de datas
+
+Base: **segunda-feira ISO** (`WorkOrderSearchDateRangeResolver`).
+
+| Preset | Intervalo |
+|--------|-----------|
+| `thisWeek` | Seg–Dom da semana ISO corrente |
+| `lastWeek` | Seg–Dom da semana ISO anterior |
+| `nextWeek` | Seg–Dom da próxima semana ISO |
+| `thisMonth` | 1º–último dia do mês corrente |
+| `nextMonth` | 1º–último dia do mês seguinte |
+| `last3Months` | Hoje − 3 meses → hoje |
+| `custom` | `dateFrom` / `dateTo` (400 se ausentes) |
+
+**Filtro de data:** `ScheduledDate` no intervalo **OU** `ScheduleWeekOnly && TargetWeek` intersectando o intervalo. Exclui templates e `IsDeleted`.
+
+---
+
+## Código entregue
+
+| Camada | Arquivo |
+|--------|---------|
+| Search filter | `SeaHaven.DataServices/Helpers/WorkOrderBoardSearchFilter.cs` |
+| Query filters | `SeaHaven.DataServices/Helpers/WorkOrderBoardQueryFilters.cs` |
+| Projeção | `SeaHaven.DataServices/Helpers/WorkOrderBoardProjection.cs` |
+| Date presets | `SeaHaven.Services/Helpers/WorkOrderSearchDateRangeResolver.cs` |
+| Advanced data | `SeaHaven.DataServices/Implementation/WorkOrderAdvancedSearchDataService.cs` |
+| Advanced service | `SeaHaven.Services/Implementation/WorkOrderAdvancedSearchService.cs` |
+| DTOs | `SeaHaven.Services/DTOs/WorkOrderBoardDTOs.cs` |
+| API | `WorkOrderController` — `GET board/search` |
+| Migration | `20260624200000_Phase4_SearchIndexes.cs` |
+| Testes | `SeaHavenIndustries.Tests/WorkOrderBoardSearchTests.cs` |
+| Load test | `scripts/load-test/work-order-search.k6.js` |
+| Seed | `scripts/seed-work-orders-search.ps1` |
+
+---
+
+## Gates de aceite
+
+### Dev (implementação)
+
+- [x] Helper de search compartilhado + testes por campo
+- [x] `GET /board/search` paginado com filtros FE
+- [x] Date presets alinhados ao SHOC (ISO Monday)
+- [x] Migration índices Phase 4
+- [x] Harness k6 + seed sintético (Tier S local)
+- [x] Endpoints legados inalterados
+- [x] ~12 testes unitários novos (total ~80)
+
+### Staging/prod (GO — pendente)
+
+- [ ] Volume Discovery preenchido — [volume-discovery-report.md](../phase-0/volume-discovery-report.md)
+- [ ] Tier assinado — [search-tier-decision.md](./search-tier-decision.md)
+- [ ] Load test em staging com volume real
+- [ ] Latência dentro do SLO do tier confirmado
+- [ ] Smoke Portal/Blazor inalterados
+
+---
+
+## SLOs Tier S (load test local)
+
+| Cenário | Endpoint | p95 |
+|---------|----------|-----|
+| Board sem search | `GET /board?weekStart=...` | &lt; 800ms |
+| Board com search | `GET /board?search=BK5` | &lt; 1000ms |
+| Advanced preset | `GET /board/search?datePreset=thisMonth` | &lt; 1200ms |
+| Advanced multi-filter | sites + types + search | &lt; 1500ms |
+
+Ver [scripts/load-test/README.md](../../scripts/load-test/README.md).
+
+---
+
+## Fora de escopo
+
+- Full-text search (Tier L)
+- Search externo dedicado (Tier XL)
+- Lookups PM catalog (`PM_TYPES`) — backlog #17
+- Alterações em endpoints legados
diff --git a/docs/work-orders/phase-4/search-tier-decision.md b/docs/work-orders/phase-4/search-tier-decision.md
new file mode 100644
index 0000000..da7dcfe
--- /dev/null
+++ b/docs/work-orders/phase-4/search-tier-decision.md
@@ -0,0 +1,51 @@
+# Search Tier Decision — Fase 4
+
+**Data:** 2026-06-24  
+**Status:** Provisório (dev) — aguardando Volume Discovery staging/prod
+
+---
+
+## Tier confirmado
+
+| Ambiente | Tier | Total WOs | Decisão |
+|----------|------|-----------|---------|
+| Dev local | **S (provisório)** | &lt; 25k sintético | Implementar SQL filtros + paginação opcional |
+| Staging | _pendente_ | _pendente acesso_ | Executar [volume-discovery-report.md](../phase-0/volume-discovery-report.md) |
+| Produção | _pendente_ | _pendente acesso_ | Executar queries read-only |
+
+---
+
+## Estratégia por tier
+
+| Tier | Volume | Estratégia advanced search |
+|------|--------|----------------------------|
+| **S** | &lt; 25k | SQL filtros compostos + paginação default 50, max 100 |
+| **M** | 25k–250k | Paginação **obrigatória** + índices covering |
+| **L** | 250k–1M | Spike full-text SQL Server — **não implementar sem spike** |
+| **XL** | &gt; 1M | Documentar ARB; search externo — **não implementar** |
+
+---
+
+## Implementação atual (Tier S)
+
+- `WorkOrderBoardSearchFilter` — filtro textual compartilhado (board + advanced)
+- `WorkOrderAdvancedSearchDataService` — query composta com `CountAsync` + `Skip/Take`
+- Índices Phase 4: `SiteCode`, `InternalWONumber`, `LifecycleStatus+ScheduledDate`
+- Min 2 caracteres em `search` para evitar full-table scan
+
+---
+
+## Próximos passos (gate staging)
+
+1. Executar `scripts/volume-discovery.ps1` contra staging read-only
+2. Preencher tabela §3 do volume report
+3. Atualizar este documento com tier real
+4. Repetir load test k6 em staging; ajustar `pageSize` max se tier = M
+
+---
+
+## Referências
+
+- [volume-discovery-report.md](../phase-0/volume-discovery-report.md)
+- [phase-4/README.md](./README.md)
+- Roadmap §10, §12 Fase 4
diff --git a/docs/work-orders/phase-5/README.md b/docs/work-orders/phase-5/README.md
new file mode 100644
index 0000000..a1a3bfb
--- /dev/null
+++ b/docs/work-orders/phase-5/README.md
@@ -0,0 +1,119 @@
+# Fase 5 — Scheduled Domain Events
+
+**Programa:** Work Orders Board  
+**Objetivo:** Jobs agendados in-process (`IHostedService`) para `WeekRolled` → `CarriedOver++` com idempotência WO+semana, audit System, cache opcional de `PastDue`, e garantia de que leituras do board continuam on-read como fonte da verdade.
+
+**Depende de:** [Fase 0](../phase-0/README.md), [Fase 1](../phase-1/README.md), [Fase 2](../phase-2/README.md), [Fase 3](../phase-3/README.md), [Fase 4](../phase-4/README.md)
+
+---
+
+## Regra de elegibilidade WeekRolled
+
+```text
+sourceWeek = semana operacional encerrada (segunda a sexta UTC)
+Elegível se:
+  - ScheduledDate.Date ∈ [sourceWeekStart, sourceWeekEnd]
+  - LifecycleStatus ∉ {Complete, Canceled, Closed}
+  - istemplate != true (ou null)
+  - Ainda não processado em WorkOrderWeekRolledLedger (WorkOrderId + SourceWeekStart)
+```
+
+**Gate PO (pendente):** confirmar se WOs só com `TargetWeek` (sem `ScheduledDate`) entram no carry-over. A implementação atual considera **apenas** WOs com `ScheduledDate` na janela.
+
+---
+
+## Idempotência
+
+Chave composta `(WorkOrderId, SourceWeekStart)` na tabela `WorkOrderWeekRolledLedger`. Re-execução do job ou endpoint admin na mesma semana não duplica `CarriedOver`.
+
+---
+
+## Contrato de audit
+
+Um evento `WeekRolled` por WO processado:
+
+| Campo | Valor |
+|-------|-------|
+| `EventType` | `System` |
+| `ActorType` | `System` |
+| `Action` | `WeekRolled` |
+| `FieldName` | `CarriedOver` |
+| `OldValue` / `NewValue` | numéricos (string) |
+| `CorrelationId` | `week:{yyyy-MM-dd}` (segunda da semana fonte) |
+
+Não aciona `ManualEditFlag` nem field locks.
+
+---
+
+## Regra de ouro — isPastDue
+
+Jobs **nunca** são fonte da verdade para `isPastDue`. O board continua calculando via `WorkOrderDerivedFields.IsPastDue` on-read. O cache `OperationalFlags.PastDue` é otimização opcional (`WorkOrderJobs:PastDueCache:Enabled`, default **false**).
+
+---
+
+## Configuração
+
+```json
+"WorkOrderJobs": {
+  "WeekRolled": { "Enabled": true, "RunAtUtc": "00:05", "DayOfWeek": "Monday" },
+  "PastDueCache": { "Enabled": false, "RunAtUtc": "00:10" }
+}
+```
+
+Variáveis de ambiente (`.env.example`):
+
+```text
+WorkOrderJobs__WeekRolled__Enabled=true
+WorkOrderJobs__PastDueCache__Enabled=false
+```
+
+---
+
+## Endpoints admin (ops-only)
+
+| Endpoint | Auth | Descrição |
+|----------|------|-----------|
+| `POST /api/workorders/jobs/week-rolled?sourceWeekStart=2026-06-16` | Admin | Reprocessa semana (segunda-feira). Idempotente. |
+| `POST /api/workorders/jobs/past-due-cache` | Admin | Atualiza cache `OperationalFlags.PastDue` |
+
+---
+
+## Código entregue
+
+| Camada | Arquivo |
+|--------|---------|
+| Ledger | `Data.SeaHavenIndustries/Models/WorkOrderWeekRolledLedger.cs` |
+| Migration | `20260624210000_Phase5_DomainEvents.cs` |
+| Data | `SeaHaven.DataServices/Implementation/WorkOrderDomainJobDataService.cs` |
+| WeekRolled | `SeaHaven.Services/Implementation/WorkOrderWeekRolledService.cs` |
+| PastDue cache | `SeaHaven.Services/Implementation/PastDueCacheService.cs` |
+| Hosted | `Api.SeaHavenIndustries/HostedServices/*.cs` |
+| API | `WorkOrderJobsController` |
+| Testes | `SeaHavenIndustries.Tests/WorkOrderWeekRolledTests.cs` |
+
+---
+
+## Monitoramento
+
+Logs estruturados com `CorrelationId` da semana. Ao concluir: `processed`, `skipped`, `failed`, `durationMs`.
+
+**Alerta ops:** se `failed > 0` ou job não executou em 8 dias → investigar + `POST /jobs/week-rolled` manual.
+
+---
+
+## Critérios de aceite
+
+- [x] Job semanal incrementa `carriedOver` para WOs elegíveis da semana anterior
+- [x] Re-execução na mesma semana não duplica (ledger WO+semana)
+- [x] Audit `WeekRolled` System com old/new `CarriedOver` e `CorrelationId`
+- [x] `GET /api/workorders/board` continua com `isPastDue` derivado on-read
+- [x] Endpoint admin permite reprocessar semana específica
+- [x] Testes cobrem idempotência, terminal skip, audit e on-read correctness
+
+---
+
+## Fora de escopo
+
+- Message queue / worker externo
+- Alteração do contrato REST do board para usar `OperationalFlags`
+- WOs week-only (`TargetWeek` sem `ScheduledDate`) — gate PO
diff --git a/docs/work-orders/phase-6/README.md b/docs/work-orders/phase-6/README.md
new file mode 100644
index 0000000..7ec8117
--- /dev/null
+++ b/docs/work-orders/phase-6/README.md
@@ -0,0 +1,159 @@
+# Fase 6 — Completion Doc e Slide-over
+
+**Programa:** Work Orders Board  
+**Objetivo:** Contrato SHOC para slide-over (`WOSlideOver`): detalhe unificado, `docStatus` WO-level com templates por serviço, e tabs Comments/Audit/Media alinhadas ao frontend.
+
+**Depende de:** [Fase 0](../phase-0/README.md) … [Fase 5](../phase-5/README.md)
+
+---
+
+## Endpoints
+
+### `GET /api/workorders/{id}/detail`
+
+Payload único para abrir o slide-over.
+
+**Autenticação:** Bearer JWT (`[Authorize]`)
+
+**Response:**
+
+```json
+{
+  "info": { /* WorkOrderDetailInfoDto — board row + description/trade/original* */ },
+  "completion": {
+    "docStatus": "No",
+    "template": { "id": 1, "name": "HVAC PM Completion", "serviceKey": "HVAC PM", "templateUrl": "..." },
+    "signOffName": null,
+    "signOffAttachment": null,
+    "signOffSignature": null,
+    "dispatchSignoffs": []
+  },
+  "comments": [{ "id": 1, "authorId": "guid", "text": "...", "time": "2026-06-01T12:00:00.0000000Z" }],
+  "audit": [{ "type": "manual", "dispatcherId": "guid", "action": "FieldChanged", "fieldName": "DocStatus", "oldValue": "No", "newValue": "Yes", "time": "..." }],
+  "media": [{ "id": 5, "category": "Extra", "url": "...", "isLegacy": false }]
+}
+```
+
+```bash
+curl -H "Authorization: Bearer <token>" \
+  "https://localhost:5001/api/workorders/42/detail"
+```
+
+---
+
+### `GET /api/workorders/{id}/audit?limit=50`
+
+Audit tab lazy refresh. Schema FE: `{ type, dispatcherId?, action, fieldName?, oldValue, newValue, time, dispatchId? }`.
+
+---
+
+### `GET /api/workorders/{id}/comments`
+
+### `POST /api/workorders/{id}/comments`
+
+```json
+{ "text": "Called vendor" }
+```
+
+Response: `{ id, authorId, text, time, documents? }`.
+
+---
+
+### Completion templates
+
+| Método | Rota | Auth | Descrição |
+|--------|------|------|-----------|
+| GET | `/api/workorders/completion-templates` | JWT | Query `serviceKey`, `workOrderType` |
+| GET | `/api/workorders/completion-templates/{id}` | JWT | Detalhe |
+| POST | `/api/workorders/completion-templates` | Admin | Criar template |
+| PUT | `/api/workorders/completion-templates/{id}` | Admin | Atualizar |
+| DELETE | `/api/workorders/completion-templates/{id}` | Admin | Soft delete |
+
+Lookup na WO: `Trade` → fallback `WorkOrderType`.
+
+---
+
+### `POST /api/workorders/{id}/completion-doc`
+
+Upload PDF preenchido (multipart).
+
+| Campo form | Obrigatório |
+|------------|-------------|
+| `file` | Sim |
+| `signOffName` | Não |
+| `signOffSignature` | Não |
+| `workOrderVersion` | Recomendado (Base64 RowVersion) |
+
+**Regras:**
+- WO read-only (`Canceled`/`Complete`/`Closed`) → 422
+- Sucesso → `SignOffAttachment` + `DocStatus=Yes` + audit `FieldChanged`
+- Dispatch signoffs → somente leitura no slide-over
+
+```bash
+curl -X POST -H "Authorization: Bearer <token>" \
+  -F "file=@completion.pdf" \
+  -F "signOffName=Jane Doe" \
+  "https://localhost:5001/api/workorders/42/completion-doc"
+```
+
+**Inline toggle:** `PATCH /api/workorders/{id}/board` com `field=docStatus` (Fase 2).
+
+---
+
+### Media
+
+| Método | Rota | Descrição |
+|--------|------|-----------|
+| GET | `/api/workorders/{id}/media` | Lista unificada com `category` |
+| POST | `/api/workorders/{id}/media` | multipart: `category` (Before/After/Extra/Completion) + `file` |
+| DELETE | `/api/workorders/{id}/media/{mediaId}` | Soft delete (somente attachments com `id > 0`) |
+
+Legacy columns (`BeforPhotoAttachment`, `AfterPhotoAttachment`, `SignOffAttachment`) aparecem na projeção com `isLegacy: true`.
+
+---
+
+## Schema
+
+Migration `Phase6_CompletionSlideOver`:
+
+- Tabela `CompletionDocTemplates`
+- Coluna `Category` em `workOrderAttachments`
+- Backfill SQL: `SignOffAttachment` preenchido → `DocStatus=Yes`
+
+Script ops: [`scripts/backfill-docstatus.ps1`](../../scripts/backfill-docstatus.ps1)
+
+---
+
+## Código entregue
+
+| Camada | Arquivo |
+|--------|---------|
+| Model | `CompletionDocTemplate.cs`, `WorkOrderMediaCategory` enum |
+| Migration | `20260625120000_Phase6_CompletionSlideOver.cs` |
+| Data | `WorkOrderDetailDataService`, `CompletionDocTemplateDataService` |
+| Services | `WorkOrderDetailService`, `WorkOrderCommentService`, `WorkOrderCompletionService`, `WorkOrderMediaService` |
+| DTOs | `WorkOrderDetailDTOs.cs` |
+| Helpers | `WorkOrderAuditProjection`, `WorkOrderCommentProjection`, `WorkOrderMediaProjection` |
+| API | `WorkOrderController` — rotas `/detail`, `/comments`, `/audit`, `/completion-doc`, `/media`, `/completion-templates` |
+| Testes | `WorkOrderPhase6Tests.cs` |
+
+---
+
+## Critérios de aceite
+
+- [x] `GET /detail` retorna Info + Completion + Comments + Audit + Media no contrato FE
+- [x] Coluna COMP DOC do board via `docStatus` no `WorkOrderBoardRowDto` (Fase 1)
+- [x] `CompletionDocTemplate` CRUD admin + lookup por `serviceKey`/`workOrderType`
+- [x] `POST completion-doc` persiste attachment, define `DocStatus=Yes`, audit
+- [x] Comments/Audit tabs sem adapter no FE
+- [x] Media com `category`; legado mapeado
+- [x] Endpoints legados (`GetWorkorderById`, `GetCommentsByWorkorderId`) inalterados
+- [x] Testes: DocStatus PATCH, detail, completion upload, comments, media
+
+---
+
+## Fora de escopo
+
+- Geração de PDF server-side
+- Alteração Vendor Portal checklist/signoff
+- Rollout / sunset Blazor (Fase 7)
diff --git a/docs/work-orders/pr-bodies/README.md b/docs/work-orders/pr-bodies/README.md
new file mode 100644
index 0000000..4d458a7
--- /dev/null
+++ b/docs/work-orders/pr-bodies/README.md
@@ -0,0 +1,28 @@
+# PR bodies (copy-paste)
+
+Full English PR descriptions are in the plan appendix and summarized below by branch tip.
+
+| PR | Branch | Tip commit | Depends on |
+|----|--------|------------|------------|
+| 1 | `feat/work-orders-phase-4` | `cbcfd9a` Phase4 index shrink | existing Phase 4 PR |
+| 2 | `feat/work-orders-completion-slideover-and-rollout` | `3e2952f` Phase6 idempotent (then stacked features) | Phase 6 base |
+| 3 | `feature/wo-structured-service-notes` | `ecc1db3` | after F2+sites on slideover stack |
+| 4 | `feature/wo-flag-color` | `62572d8` | after service notes |
+| 5 | `feature/wo-board-search-paging` | `1eaf9b7` | after flag (or notes) |
+| 6 | `feature/wo-comments-author-edit` | `16b31e5` | after search (controller mixed) |
+| 7 | `feature/location-sites-vendor-contact` | `3983f76` | after F2 |
+
+Stacked history on `feat/work-orders-completion-slideover-and-rollout` (`f61aff0`, ahead 7):
+
+1. fix Phase6 migration
+2. feat locations/sites + vendor contactName
+3. feat structured service notes
+4. feat flagColor
+5. feat search/paging
+6. feat comment edit / display names
+7. docs staff review findings
+
+Phase4 hardening lives only on `feat/work-orders-phase-4`.
+
+Full PR markdown: see conversation / plan Apêndice B.
+Staff findings: [staff-review-findings.md](../staff-review-findings.md)
diff --git a/docs/work-orders/staff-review-findings.md b/docs/work-orders/staff-review-findings.md
new file mode 100644
index 0000000..2ae4210
--- /dev/null
+++ b/docs/work-orders/staff-review-findings.md
@@ -0,0 +1,276 @@
+# Staff Review Findings — Work Orders (Fase 2)
+
+Adversarial reviews per delivery. Do not treat preliminary inventário notes as final.
+
+---
+
+## Entrega A — Structured Service Notes / POC / Tech-Vendor
+
+### How it works
+
+1. **Create** `POST /api/workorders/board`: FluentValidation → resolve `primaryService`/`trade` → serialize `extraServices` JSON → persist POC/service/tech/vendor on `WorkOrder`; if vendor/appt present, create `Dispatch` and store tech/vendor notes there instead of WO.
+2. **Patch** `PATCH .../board` with `pm` | `serviceNotes` | `extraServices`.
+3. **Read**: board projection prefers WO POC fields over `WorkOrderContacts`; tech phone = Dispatch.TechPhone → WO.TechPhone → Vendor.Phone. Detail exposes `serviceNotes`, `extraServices`, `vendorNotes`.
+
+### Domain invariants
+
+- Extra services require a primary service on create.
+- Tech/vendor notes live on dispatch when a vendor dispatch exists; otherwise on WO.
+- Board POC free-text overrides linked contact projection.
+
+### Half-done
+
+- No board PATCH for `pocName` / `pocPhone` / `pocNotes` / `techPhone` / `vendorNotes` (create-only for those).
+- `ParseExtraServices` duplicated in board + detail services.
+- Create validation file has excessive blank lines (noise).
+- Test `PatchField_ExtraServicesWithoutPrimary_Throws` disagrees with promotion logic in `ApplyExtraServices`.
+
+### Findings
+
+#### A1 — ExtraServices without primary: test vs promotion
+
+- **Severity:** High
+- **File:** `SeaHaven.Services/Implementation/WorkOrderBoardUpdateService.cs` (~294–298); test `WorkOrderBoardUpdateServiceTests.cs` (~331)
+- **Explanation:** Create requires primary when extras exist; PATCH promotes first extra to `Trade` without auditing Trade. Test expects `InvalidValue`.
+- **Scenario:** Legacy WO with empty Trade; FE patches `extraServices` only.
+- **Repro:** PATCH `extraServices=["Filter change"]` on WO with null Trade.
+- **Fix:** Reject when Trade empty (align create + test); do not promote silently.
+- **When:** **Now** (blocks green CI / domain consistency).
+
+#### A2 — ExtraServices JSON can exceed nvarchar(2000)
+
+- **Severity:** High
+- **File:** Create `SerializeExtraServices`; Update `ApplyExtraServices`
+- **Explanation:** Per-item max 128; no check on serialized JSON length vs column 2000.
+- **Scenario:** Many extras → `DbUpdateException` 500.
+- **Repro:** PATCH/create with ~20×128-char labels.
+- **Fix:** After serialize, throw `InvalidValue` if length > 2000.
+- **When:** **Now**.
+
+#### A3 — Create does not cap ExtraServices JSON length / per-item in serializer
+
+- **Severity:** Medium
+- **File:** `WorkOrderBoardCreateService.SerializeExtraServices`
+- **Explanation:** FluentValidation caps each item at 128 but create serializer does not re-validate length or total JSON; update path has item length check, create does not.
+- **Fix:** Share normalize helper; enforce item + JSON caps on create.
+- **When:** **Now** (with A2).
+
+#### A4 — POC / tech / vendor notes not patchable on board
+
+- **Severity:** Medium
+- **File:** `WorkOrderBoardFieldNames.cs` / UpdateService
+- **Explanation:** Create persists structured POC/tech/vendor; no PATCH fields → FE cannot edit after create without another API.
+- **When:** **Later** if FE has another edit path; otherwise before FE ship.
+
+#### A5 — Dual POC sources can diverge
+
+- **Severity:** Low
+- **File:** CreateService + Projection
+- **Explanation:** `PocContactId` + free-text both allowed; board prefers free-text; contact row may hold different notes.
+- **When:** Later (document or clear contact notes when free-text set).
+
+#### A6 — Duplicate ParseExtraServices
+
+- **Severity:** Low
+- **File:** `WorkOrderBoardService.cs`, `WorkOrderDetailService.cs`
+- **When:** Later (extract helper).
+
+### Verdict A
+
+**Merge blocked** until A1–A3 fixed. A4 is a product gap for FE edit flows.
+
+---
+
+## Entrega B — Flag Color
+
+### How it works
+
+PATCH `flagColor` → normalize `#RRGGBB` → whitelist palette → persist on WO → project on board/detail. Distinct from dispatcher avatar `color`.
+
+### Half-done
+
+- None material. Migration + model + PATCH + tests present.
+
+### Findings
+
+#### B1 — No finding Critical/High
+
+Palette enforcement and clear semantics are consistent with tests.
+
+#### B2 — Snapshot/model coupled with Entrega A
+
+- **Severity:** Low (process)
+- **Explanation:** Same `WorkerOrder` / snapshot file as service notes; branch split needs careful ordering.
+- **When:** During organize.
+
+### Verdict B
+
+**OK to merge** after A schema lands (or same branch ordered commits). No code blockers unique to B.
+
+---
+
+## Entrega C — Search / overdue / paging
+
+### How it works
+
+Advanced search: normalize page (≥0), pageSize≤100, resolve Mon–Fri presets, whitelist sortBy, apply type/overdue/unscheduled filters, project board rows. Board GET maps `ArgumentException` → 400.
+
+### Half-done / risks
+
+- Shared `PagedResult` flipped to 0-based helpers while Location/Contact/etc. still use 1-based `page` defaults.
+
+### Findings
+
+#### C1 — PagedResult 0-based breaks 1-based APIs
+
+- **Severity:** Critical
+- **File:** `SeaHaven.Services/DTOs/ContactDTOs.cs`
+- **Explanation:** `HasPrevious`/`HasNext` assume 0-based; Location etc. pass `page=1` on first page → `HasPrevious=true` incorrectly; last-page `HasNext` wrong for 0-based search too if mixed.
+- **Scenario:** Any paged Location/Contact/Vendor list UI using helpers.
+- **Fix:** Restore 1-based helpers by default; opt-in 0-based for WO search only (`PageBase` or dedicated DTO).
+- **When:** **Now**.
+
+#### C2 — Unscheduled always included in date range
+
+- **Severity:** High
+- **File:** `WorkOrderBoardQueryFilters.ApplyDateRangeFilter`
+- **Explanation:** Every advanced search with a date range also returns all unscheduled non-terminal WOs → unbounded result growth.
+- **Scenario:** Narrow custom range + large backlog of undated WOs.
+- **Fix:** Explicit `includeUnscheduled` or cap; confirm FE intent.
+- **When:** Confirm with FE; fix before prod if unintentional.
+
+#### C3 — WorkOrderType.Other = overdue sentinel
+
+- **Severity:** High (domain)
+- **File:** `WorkOrderBoardQueryFilters.ApplyTypeAndOverdueFilter`
+- **Explanation:** Cannot filter real `Other` types via `types=99`.
+- **When:** Document now; long-term separate `isPastDue` query param.
+
+#### C4 — Label search `label.Contains(s)` matches short tokens broadly
+
+- **Severity:** Medium
+- **File:** `WorkOrderBoardSearchFilter`
+- **When:** Later / monitor perf.
+
+#### C5 — Overdue uses UTC date vs possibly local scheduled dates
+
+- **Severity:** Medium
+- **File:** QueryFilters / search filter
+- **When:** Later if US sites report off-by-one day.
+
+#### C6 — Search helper methods not EF-translatable (FIXED)
+
+- **Severity:** Critical
+- **File:** `WorkOrderBoardSearchFilter.Apply`
+- **Explanation:** Refactor extracted `Matches*` private methods; EF Core InMemory/SQL cannot translate them → all text searches throw at runtime.
+- **Repro:** Any `search` with length ≥ 2 on board/search.
+- **Fix:** Inline predicates in the `Where` expression (applied).
+- **When:** **Now** — fixed during Fase 2.
+
+### Verdict C
+
+**Merge blocked** on C1 (fixed via `PageBase`) and C6 (fixed via inline predicates). C2 needs product confirmation. Prefer separate PR.
+
+---
+
+## Entrega D — Comments edit + display names
+
+### How it works
+
+`GetDisplayNamesByIdsAsync` → comment/audit projections. PATCH comment: author or Admin; General+WorkOrder only; read-only WO blocked.
+
+### Half-done
+
+- Comment edit not written to audit log.
+
+### Findings
+
+#### D1 — Comment updates leave no audit trail
+
+- **Severity:** Medium
+- **File:** `WorkOrderCommentService.UpdateCommentAsync`
+- **When:** Later if compliance requires it; note in PR.
+
+#### D2 — No max length on comment text on update
+
+- **Severity:** Low (pre-existing on create)
+- **When:** Later.
+
+### Verdict D
+
+**OK to merge** with D1 noted. No Critical/High code defects found.
+
+---
+
+## Entrega E — Sites + Vendor ContactName
+
+### How it works
+
+`GET /api/locations/sites?search=` → Id/Code/City/State (`Code` ← `Locations.Name`). Vendor Dropdown adds `contactName`.
+
+### Findings
+
+#### E1 — GetSites unbounded
+
+- **Severity:** Medium
+- **File:** `LocationDataService.GetSiteOptionsAsync`
+- **Explanation:** No Take/limit; large Locations table → heavy payload.
+- **When:** Later or add Take(500) if volume unknown.
+
+#### E2 — No soft-delete filter
+
+- **Severity:** Low
+- **Explanation:** Locations inherit audit entity; if soft-delete used elsewhere, sites may include deleted.
+- **When:** Later if soft-delete applies to Locations.
+
+### Verdict E
+
+**OK to merge** independently.
+
+---
+
+## Entrega F1 — Phase4 migration hardening
+
+### How it works
+
+Before creating indexes, alter `SiteCode`/`InternalWONumber` to nvarchar(450).
+
+### Findings
+
+#### F1-1 — Editing already-shipped migration
+
+- **Severity:** High (ops)
+- **File:** `20260624200000_Phase4_SearchIndexes.cs`
+- **Explanation:** Environments that already applied old `Up` will not re-run. Failed partial applies need manual repair or a **new** migration.
+- **When:** Verify `__EFMigrationsHistory` per environment **before** merge. Prefer new corrective migration if any env already applied.
+
+### Verdict F1
+
+**Conditional merge** after env check. Apply on `feat/work-orders-phase-4` only.
+
+---
+
+## Entrega F2 — Phase6 migration hardening
+
+### How it works
+
+Idempotent SQL for Category column, CompletionDocTemplates, index; EF attributes for discovery.
+
+### Findings
+
+#### F2-1 — Same applied-migration caveat as F1
+
+- **Severity:** High (ops)
+- **When:** Verify env history; idempotent SQL helps partial DBs if migration re-run manually, not if EF skips applied migrations.
+
+### Verdict F2
+
+**Conditional merge** on slideover branch after env check.
+
+---
+
+## Cross-cutting mandatory fixes before organize
+
+1. A1 — ExtraServices without primary throws  
+2. A2/A3 — JSON length ≤ 2000  
+3. C1 — PagedResult 1-based default + WO search 0-based opt-in  
diff --git a/scripts/backfill-docstatus.ps1 b/scripts/backfill-docstatus.ps1
new file mode 100644
index 0000000..4bcc0e0
--- /dev/null
+++ b/scripts/backfill-docstatus.ps1
@@ -0,0 +1,23 @@
+# Backfill DocStatus from legacy SignOffAttachment (idempotent)
+# Run against target SQL Server after Phase6_CompletionSlideOver migration.
+
+param(
+    [string]$ConnectionString = $env:ConnectionStrings__DefaultConnection
+)
+
+if ([string]::IsNullOrWhiteSpace($ConnectionString)) {
+    Write-Error "Set ConnectionStrings__DefaultConnection or pass -ConnectionString"
+    exit 1
+}
+
+$sql = @"
+UPDATE workOrders
+SET DocStatus = 1
+WHERE DocStatus IS NULL
+  AND SignOffAttachment IS NOT NULL
+  AND LTRIM(RTRIM(SignOffAttachment)) <> '';
+"@
+
+Write-Host "Backfilling DocStatus=Yes where SignOffAttachment exists..."
+Invoke-Sqlcmd -ConnectionString $ConnectionString -Query $sql
+Write-Host "Done."
diff --git a/scripts/load-test/README.md b/scripts/load-test/README.md
new file mode 100644
index 0000000..c068043
--- /dev/null
+++ b/scripts/load-test/README.md
@@ -0,0 +1,40 @@
+# Load Test — Work Order Search (Tier S)
+
+Harness k6 para validar SLOs da Fase 4 em ambiente local ou staging.
+
+## Pré-requisitos
+
+- [k6](https://k6.io/docs/get-started/installation/) instalado
+- API rodando com JWT válido
+- (Opcional) Seed sintético: `scripts/seed-work-orders-search.ps1 -Count 15000`
+
+## Variáveis de ambiente
+
+| Variável | Descrição | Default |
+|----------|-----------|---------|
+| `BASE_URL` | URL base da API | `https://localhost:5001` |
+| `JWT` | Bearer token | _(obrigatório)_ |
+| `WEEK_START` | Segunda-feira ISO para board | `2026-06-22` |
+
+## Execução
+
+```powershell
+$env:JWT = "<seu-token>"
+$env:BASE_URL = "https://localhost:5001"
+k6 run scripts/load-test/work-order-search.k6.js
+```
+
+## SLOs Tier S (p95)
+
+| Métrica | Limite |
+|---------|--------|
+| `board_no_search` | &lt; 800ms |
+| `board_with_search` | &lt; 1000ms |
+| `advanced_preset` | &lt; 1200ms |
+| `advanced_multi_filter` | &lt; 1500ms |
+
+## Staging (pós Volume Discovery)
+
+1. Executar `scripts/volume-discovery.ps1`
+2. Confirmar tier em `docs/work-orders/phase-4/search-tier-decision.md`
+3. Repetir k6 com volume real; ajustar thresholds se tier = M
diff --git a/scripts/load-test/work-order-search.k6.js b/scripts/load-test/work-order-search.k6.js
new file mode 100644
index 0000000..ff69d67
--- /dev/null
+++ b/scripts/load-test/work-order-search.k6.js
@@ -0,0 +1,60 @@
+import http from 'k6/http';
+import { check, sleep } from 'k6';
+import { Trend } from 'k6/metrics';
+
+const boardNoSearch = new Trend('board_no_search', true);
+const boardWithSearch = new Trend('board_with_search', true);
+const advancedPreset = new Trend('advanced_preset', true);
+const advancedMultiFilter = new Trend('advanced_multi_filter', true);
+
+const BASE_URL = __ENV.BASE_URL || 'https://localhost:5001';
+const JWT = __ENV.JWT || '';
+const WEEK_START = __ENV.WEEK_START || '2026-06-22';
+
+export const options = {
+  vus: 10,
+  duration: '30s',
+  thresholds: {
+    board_no_search: ['p(95)<800'],
+    board_with_search: ['p(95)<1000'],
+    advanced_preset: ['p(95)<1200'],
+    advanced_multi_filter: ['p(95)<1500'],
+  },
+};
+
+const headers = {
+  Authorization: `Bearer ${JWT}`,
+  Accept: 'application/json',
+};
+
+export default function () {
+  const boardRes = http.get(
+    `${BASE_URL}/api/workorders/board?weekStart=${WEEK_START}`,
+    { headers }
+  );
+  boardNoSearch.add(boardRes.timings.duration);
+  check(boardRes, { 'board 200': (r) => r.status === 200 });
+
+  const searchRes = http.get(
+    `${BASE_URL}/api/workorders/board?weekStart=${WEEK_START}&search=BK5`,
+    { headers }
+  );
+  boardWithSearch.add(searchRes.timings.duration);
+  check(searchRes, { 'board search 200': (r) => r.status === 200 });
+
+  const advRes = http.get(
+    `${BASE_URL}/api/workorders/board/search?datePreset=thisMonth&page=1&pageSize=50`,
+    { headers }
+  );
+  advancedPreset.add(advRes.timings.duration);
+  check(advRes, { 'advanced preset 200': (r) => r.status === 200 });
+
+  const multiRes = http.get(
+    `${BASE_URL}/api/workorders/board/search?datePreset=thisMonth&sites=BK5&types=PM&search=HVAC&page=1`,
+    { headers }
+  );
+  advancedMultiFilter.add(multiRes.timings.duration);
+  check(multiRes, { 'advanced multi 200': (r) => r.status === 200 });
+
+  sleep(0.5);
+}
diff --git a/scripts/seed-work-orders-search.ps1 b/scripts/seed-work-orders-search.ps1
new file mode 100644
index 0000000..a08b18a
--- /dev/null
+++ b/scripts/seed-work-orders-search.ps1
@@ -0,0 +1,56 @@
+# Seed sintético de Work Orders para load test Tier S
+#
+# Uso:
+#   $env:SQL_CONNECTION_STRING = "Server=localhost;Database=SeaHaven;..."
+#   .\scripts\seed-work-orders-search.ps1 -Count 15000
+
+param(
+    [int]$Count = 5000,
+    [string]$ConnectionString = $env:SQL_CONNECTION_STRING
+)
+
+if ([string]::IsNullOrWhiteSpace($ConnectionString)) {
+    Write-Error "Defina SQL_CONNECTION_STRING ou passe -ConnectionString."
+    exit 1
+}
+
+$sites = @("BK5", "BK6", "BK7", "BK8", "BK9", "LA1", "LA2", "NY1")
+$trades = @("HVAC PM", "Plumbing PM", "Electrical PM", "Roof Inspection", "Fire Safety")
+$baseDate = Get-Date "2026-01-06"
+
+Write-Host "Inserindo $Count WOs sintéticas..." -ForegroundColor Cyan
+
+$batchSize = 500
+$inserted = 0
+
+while ($inserted -lt $Count) {
+    $batch = [Math]::Min($batchSize, $Count - $inserted)
+    $values = @()
+
+    for ($i = 0; $i -lt $batch; $i++) {
+        $id = $inserted + $i + 1
+        $site = $sites[$id % $sites.Length]
+        $trade = $trades[$id % $trades.Length]
+        $weekOffset = $id % 52
+        $scheduled = $baseDate.AddDays($weekOffset * 7 + ($id % 5))
+        $woNumber = ("1{0:D10}" -f $id)
+
+        $values += "('$woNumber', '$site', '$trade', '$($scheduled.ToString('yyyy-MM-dd'))', 2, 0)"
+    }
+
+    $sql = @"
+INSERT INTO workOrders (InternalWONumber, SiteCode, Trade, ScheduledDate, LifecycleStatus, istemplate, RescheduleCount, CarriedOver, CreatedDate)
+VALUES $($values -join ',');
+"@
+
+    sqlcmd -Q $sql -b
+    if ($LASTEXITCODE -ne 0) {
+        Write-Error "Falha no batch $inserted"
+        exit 1
+    }
+
+    $inserted += $batch
+    Write-Host "  $inserted / $Count"
+}
+
+Write-Host "Seed concluído." -ForegroundColor Green
diff --git a/scripts/spike-status-mapping.sql b/scripts/spike-status-mapping.sql
new file mode 100644
index 0000000..14e371b
--- /dev/null
+++ b/scripts/spike-status-mapping.sql
@@ -0,0 +1,90 @@
+-- Spike Status Mapping (G2): seed legado + enum compacto + queries de análise
+-- Executar APÓS dotnet ef database update
+-- Uso: sqlcmd -S localhost,1433 -U sa -P "SeaHaven_Dev_2026!" -d SeahavenIndustries -C -i scripts/spike-status-mapping.sql
+
+SET NOCOUNT ON;
+
+-- ---------------------------------------------------------------------------
+-- 1. Seed status spike (prefixo SPIKE-STATUS-)
+--    Cobre formatos legado (com espaço) e canônico API (enum ToString)
+-- ---------------------------------------------------------------------------
+IF NOT EXISTS (SELECT 1 FROM workOrders WHERE InternalWONumber LIKE 'SPIKE-STATUS-%')
+BEGIN
+    DECLARE @weekStart date = CAST(GETDATE() AS date);
+
+    INSERT INTO workOrders (
+        InternalWONumber, WorkerOrderTitle, SiteCode, Status, Priority,
+        ScheduledDate, DueDate, Trade, Problem, AssignTo, istemplate, CreatedDate
+    )
+    VALUES
+    -- Legado Blazor / Sync (com espaço)
+    ('SPIKE-STATUS-001', 'Status spike - Open legado',       'SS1', 'Open',         'Medium', DATEADD(day, 0, @weekStart), DATEADD(day, 5, @weekStart),  'HVAC', 'Repair', NULL, 0, GETDATE()),
+    ('SPIKE-STATUS-002', 'Status spike - In Progress legado','SS2', 'In Progress',  'Medium', DATEADD(day, 1, @weekStart), DATEADD(day, 6, @weekStart),  'Plumbing', 'Repair', NULL, 0, GETDATE()),
+    ('SPIKE-STATUS-003', 'Status spike - On Hold legado',    'SS3', 'On Hold',      'Low',    DATEADD(day, 2, @weekStart), DATEADD(day, 10, @weekStart), 'Electrical', 'Hold', NULL, 0, GETDATE()),
+    ('SPIKE-STATUS-004', 'Status spike - Done legado',       'SS4', 'Done',         'Low',    DATEADD(day, 3, @weekStart), DATEADD(day, 4, @weekStart),  'General', 'Complete', NULL, 0, GETDATE()),
+    ('SPIKE-STATUS-005', 'Status spike - Cancelled legado',  'SS5', 'Cancelled',    'Low',    DATEADD(day, 4, @weekStart), DATEADD(day, 8, @weekStart),  'HVAC', 'Cancelled', NULL, 0, GETDATE()),
+    ('SPIKE-STATUS-006', 'Status spike - UnAssigned legado','SS6', 'UnAssigned',   'Medium', DATEADD(day, 5, @weekStart), DATEADD(day, 7, @weekStart),  'Plumbing', 'Unassigned', NULL, 0, GETDATE()),
+    -- Canônico API (enum ToString)
+    ('SPIKE-STATUS-007', 'Status spike - Open canônico',     'SS7', 'Open',         'Medium', DATEADD(day, 0, @weekStart), DATEADD(day, 5, @weekStart),  'HVAC', 'Repair', NULL, 0, GETDATE()),
+    ('SPIKE-STATUS-008', 'Status spike - InProgress canônico','SS8', 'InProgress',  'High',   DATEADD(day, 1, @weekStart), DATEADD(day, 6, @weekStart),  'Plumbing', 'Repair', NULL, 0, GETDATE()),
+    ('SPIKE-STATUS-009', 'Status spike - OnHold canônico',   'SS9', 'OnHold',       'Low',    DATEADD(day, 2, @weekStart), DATEADD(day, 10, @weekStart), 'Electrical', 'Hold', NULL, 0, GETDATE()),
+    ('SPIKE-STATUS-010', 'Status spike - Completed canônico','SS10','Completed',    'Low',    DATEADD(day, 3, @weekStart), DATEADD(day, 4, @weekStart),  'General', 'Complete', NULL, 0, GETDATE()),
+    ('SPIKE-STATUS-011', 'Status spike - Cancelled canônico','SS11','Cancelled',    'Low',    DATEADD(day, 4, @weekStart), DATEADD(day, 8, @weekStart),  'HVAC', 'Cancelled', NULL, 0, GETDATE()),
+    -- Open sem assignee (derivado Unassigned no board)
+    ('SPIKE-STATUS-012', 'Status spike - Open unassigned',   'SS12','Open',         'Medium', DATEADD(day, 1, @weekStart), DATEADD(day, 3, @weekStart),  'HVAC', 'Repair', NULL, 0, GETDATE()),
+    -- Past due candidato (scheduled no passado, status não terminal)
+    ('SPIKE-STATUS-013', 'Status spike - past due candidate','SS13','In Progress',  'High',   DATEADD(day, -3, @weekStart), DATEADD(day, -1, @weekStart), 'HVAC', 'Overdue test', NULL, 0, GETDATE());
+
+    PRINT 'Seed status spike: 13 work orders inseridos (prefixo SPIKE-STATUS-).';
+END
+ELSE
+    PRINT 'Seed status spike: já existente — pulando INSERT.';
+GO
+
+-- ---------------------------------------------------------------------------
+-- 2. Distribuição Status (todos os WOs não-template)
+-- ---------------------------------------------------------------------------
+PRINT '--- Distribuição Status ---';
+SELECT Status, COUNT(*) AS Cnt
+FROM workOrders
+WHERE istemplate IS NULL OR istemplate = 0
+GROUP BY Status
+ORDER BY Cnt DESC;
+
+-- ---------------------------------------------------------------------------
+-- 3. Status x assignee (detectar Unassigned implícito)
+-- ---------------------------------------------------------------------------
+PRINT '--- Status x AssignTo (Unassigned implícito) ---';
+SELECT
+    Status,
+    CASE WHEN AssignTo IS NULL OR LTRIM(RTRIM(AssignTo)) = '' THEN 1 ELSE 0 END AS IsUnassigned,
+    COUNT(*) AS Cnt
+FROM workOrders
+WHERE istemplate IS NULL OR istemplate = 0
+GROUP BY Status,
+         CASE WHEN AssignTo IS NULL OR LTRIM(RTRIM(AssignTo)) = '' THEN 1 ELSE 0 END
+ORDER BY Status, IsUnassigned;
+
+-- ---------------------------------------------------------------------------
+-- 4. Órfãos — valores não mapeáveis pelo mapper G2 (ajustar lista conforme spike)
+-- ---------------------------------------------------------------------------
+PRINT '--- Status órfãos (fora do vocabulário conhecido) ---';
+SELECT Status, COUNT(*) AS Cnt
+FROM workOrders
+WHERE (istemplate IS NULL OR istemplate = 0)
+  AND Status IS NOT NULL
+  AND LTRIM(RTRIM(Status)) NOT IN (
+    'Open', 'In Progress', 'On Hold', 'Done', 'Cancelled', 'UnAssigned', 'Unassigned',
+    'InProgress', 'OnHold', 'Completed',
+    'new', 'assigned', 'in_progress', 'on_hold', 'completed', 'cancelled', 'unknown'
+  )
+GROUP BY Status
+ORDER BY Cnt DESC;
+
+-- ---------------------------------------------------------------------------
+-- 5. Template query PRODUÇÃO (rodar manualmente em prod/staging)
+-- ---------------------------------------------------------------------------
+PRINT '--- Template query PRODUÇÃO ---';
+-- SELECT Status, COUNT(*) AS Cnt FROM workOrders WHERE istemplate IS NULL OR istemplate = 0 GROUP BY Status ORDER BY Cnt DESC;
+
+GO
diff --git a/scripts/spike-work-order-type.sql b/scripts/spike-work-order-type.sql
new file mode 100644
index 0000000..0c18465
--- /dev/null
+++ b/scripts/spike-work-order-type.sql
@@ -0,0 +1,96 @@
+-- Spike WorkOrderType: coluna legada + seed local + queries de análise
+-- Executar APÓS dotnet ef database update
+-- Uso: sqlcmd -S localhost,1433 -U sa -P "SeaHaven_Dev_2026!" -d SeahavenIndustries -C -i scripts/spike-work-order-type.sql
+
+SET NOCOUNT ON;
+
+-- ---------------------------------------------------------------------------
+-- 1. Colunas legadas (existem em prod/db.txt, ausentes nas migrations EF)
+-- ---------------------------------------------------------------------------
+IF COL_LENGTH('workOrders', 'WorkOrderType') IS NULL
+    ALTER TABLE workOrders ADD WorkOrderType varchar(50) NULL;
+
+IF COL_LENGTH('workOrders', 'AvettaTask') IS NULL
+    ALTER TABLE workOrders ADD AvettaTask varchar(max) NULL;
+
+IF COL_LENGTH('workOrders', 'AssignDate') IS NULL
+    ALTER TABLE workOrders ADD AssignDate date NULL;
+
+GO
+
+-- ---------------------------------------------------------------------------
+-- 2. Seed spike (somente se ainda não existir prefixo SPIKE-WO-)
+-- ---------------------------------------------------------------------------
+IF NOT EXISTS (SELECT 1 FROM workOrders WHERE InternalWONumber LIKE 'SPIKE-WO-%')
+BEGIN
+    DECLARE @weekStart date = CAST(GETDATE() AS date);
+    DECLARE @weekEnd date = DATEADD(day, 6, @weekStart);
+
+    INSERT INTO workOrders (
+        InternalWONumber, WorkerOrderTitle, SiteCode, Status, Priority,
+        ScheduledDate, DueDate, Trade, Problem, WorkOrderType, istemplate, CreatedDate
+    )
+    VALUES
+    -- NULL WorkOrderType (5)
+    ('SPIKE-WO-001', 'Spike seed - null type A', 'BK5', 'Open', 'Medium', DATEADD(day, 0, @weekStart), DATEADD(day, 3, @weekStart), 'HVAC', 'Cooling', NULL, 0, GETDATE()),
+    ('SPIKE-WO-002', 'Spike seed - null type B', 'BK6', 'Open', 'Low', DATEADD(day, 1, @weekStart), DATEADD(day, 5, @weekStart), 'Plumbing', 'Leak', NULL, 0, GETDATE()),
+    ('SPIKE-WO-003', 'Spike seed - null type C', 'BK7', 'InProgress', 'Medium', DATEADD(day, 2, @weekStart), DATEADD(day, 4, @weekStart), 'Electrical', 'Panel', NULL, 0, GETDATE()),
+    ('SPIKE-WO-004', 'Spike seed - null type D', 'BK8', 'Open', 'High', DATEADD(day, 3, @weekStart), DATEADD(day, 7, @weekStart), 'HVAC', 'Filter', NULL, 0, GETDATE()),
+    ('SPIKE-WO-005', 'Spike seed - null type E', 'BK9', 'OnHold', 'Low', DATEADD(day, 4, @weekStart), DATEADD(day, 10, @weekStart), 'General', 'Inspection', NULL, 0, GETDATE()),
+    -- PM (5)
+    ('SPIKE-WO-006', 'Spike seed - PM A', 'PM1', 'Open', 'Medium', DATEADD(day, 0, @weekStart), DATEADD(day, 14, @weekStart), 'HVAC', 'Preventive Maintenance', 'PM', 0, GETDATE()),
+    ('SPIKE-WO-007', 'Spike seed - PM B', 'PM2', 'Open', 'Medium', DATEADD(day, 1, @weekStart), DATEADD(day, 14, @weekStart), 'Plumbing', 'PM Schedule', 'PM', 0, GETDATE()),
+    ('SPIKE-WO-008', 'Spike seed - PM C', 'PM3', 'InProgress', 'Low', DATEADD(day, 2, @weekStart), DATEADD(day, 21, @weekStart), 'Electrical', 'Quarterly PM', 'PM', 0, GETDATE()),
+    ('SPIKE-WO-009', 'Spike seed - PM D', 'PM4', 'Open', 'Medium', DATEADD(day, 5, @weekStart), DATEADD(day, 30, @weekStart), 'HVAC', 'Annual PM', 'PM', 0, GETDATE()),
+    ('SPIKE-WO-010', 'Spike seed - PM E', 'PM5', 'Open', 'Low', DATEADD(day, 6, @weekStart), DATEADD(day, 7, @weekStart), 'General', 'PM', 'PM', 0, GETDATE()),
+    -- Standard (4)
+    ('SPIKE-WO-011', 'Spike seed - Standard A', 'ST1', 'Open', 'Medium', DATEADD(day, 0, @weekStart), DATEADD(day, 5, @weekStart), 'HVAC', 'Repair', 'Standard', 0, GETDATE()),
+    ('SPIKE-WO-012', 'Spike seed - Standard B', 'ST2', 'InProgress', 'High', DATEADD(day, 2, @weekStart), DATEADD(day, 6, @weekStart), 'Plumbing', 'Repair', 'Standard', 0, GETDATE()),
+    ('SPIKE-WO-013', 'Spike seed - Standard C', 'ST3', 'Open', 'Medium', DATEADD(day, 4, @weekStart), DATEADD(day, 8, @weekStart), 'Electrical', 'Repair', 'Standard', 0, GETDATE()),
+    ('SPIKE-WO-014', 'Spike seed - Standard D', 'ST4', 'Completed', 'Low', DATEADD(day, 1, @weekStart), DATEADD(day, 2, @weekStart), 'General', 'Repair', 'Standard', 0, GETDATE()),
+    -- Add-On (3)
+    ('SPIKE-WO-015', 'Spike seed - Add-On A', 'AO1', 'Open', 'Medium', DATEADD(day, 3, @weekStart), DATEADD(day, 9, @weekStart), 'HVAC', 'Add work', 'Add-On', 0, GETDATE()),
+    ('SPIKE-WO-016', 'Spike seed - Add-On B', 'AO2', 'Open', 'High', DATEADD(day, 4, @weekStart), DATEADD(day, 10, @weekStart), 'Plumbing', 'Add work', 'Add-On', 0, GETDATE()),
+    ('SPIKE-WO-017', 'Spike seed - Add-On C', 'AO3', 'InProgress', 'Medium', DATEADD(day, 5, @weekStart), DATEADD(day, 11, @weekStart), 'Electrical', 'Add work', 'Add-On', 0, GETDATE()),
+    -- Emergency + Corrective (3)
+    ('SPIKE-WO-018', 'Spike seed - Emergency', 'EM1', 'Open', 'Critical', DATEADD(day, 0, @weekStart), DATEADD(day, 1, @weekStart), 'HVAC', 'Emergency', 'Emergency', 0, GETDATE()),
+    ('SPIKE-WO-019', 'Spike seed - Corrective A', 'CR1', 'Open', 'High', DATEADD(day, 2, @weekStart), DATEADD(day, 4, @weekStart), 'Plumbing', 'Corrective', 'Corrective', 0, GETDATE()),
+    ('SPIKE-WO-020', 'Spike seed - Corrective B', 'CR2', 'Open', 'Medium', DATEADD(day, 6, @weekStart), DATEADD(day, 8, @weekStart), 'General', 'Corrective', 'Corrective', 0, GETDATE());
+
+    PRINT 'Seed spike: 20 work orders inseridos (prefixo SPIKE-WO-).';
+END
+ELSE
+    PRINT 'Seed spike: já existente — pulando INSERT.';
+GO
+
+-- ---------------------------------------------------------------------------
+-- 3. Queries de análise (entregável spike)
+-- ---------------------------------------------------------------------------
+PRINT '--- Distribuição WorkOrderType (seed + existentes) ---';
+SELECT WorkOrderType, COUNT(*) AS Cnt
+FROM workOrders
+WHERE istemplate IS NULL OR istemplate = 0
+GROUP BY WorkOrderType
+ORDER BY Cnt DESC;
+
+PRINT '--- % populado ---';
+SELECT
+    COUNT(*) AS TotalRows,
+    SUM(CASE WHEN WorkOrderType IS NOT NULL AND LTRIM(RTRIM(WorkOrderType)) <> '' THEN 1 ELSE 0 END) AS Populated,
+    CAST(100.0 * SUM(CASE WHEN WorkOrderType IS NOT NULL AND LTRIM(RTRIM(WorkOrderType)) <> '' THEN 1 ELSE 0 END) / NULLIF(COUNT(*), 0) AS decimal(5,2)) AS PopulatedPct
+FROM workOrders
+WHERE istemplate IS NULL OR istemplate = 0;
+
+PRINT '--- Cruzamento Problem/Trade (hipótese derivação) ---';
+SELECT WorkOrderType, Problem, Trade, COUNT(*) AS Cnt
+FROM workOrders
+WHERE (istemplate IS NULL OR istemplate = 0)
+  AND (InternalWONumber LIKE 'SPIKE-WO-%' OR WorkOrderType IS NOT NULL)
+GROUP BY WorkOrderType, Problem, Trade
+ORDER BY WorkOrderType, Cnt DESC;
+
+PRINT '--- Template query PRODUÇÃO (rodar manualmente em prod/staging) ---';
+-- SELECT WorkOrderType, COUNT(*) FROM workOrders GROUP BY WorkOrderType;
+-- SELECT COUNT(*) AS Total, SUM(CASE WHEN WorkOrderType IS NOT NULL THEN 1 ELSE 0 END) AS WithType FROM workOrders;
+
+GO
diff --git a/scripts/volume-discovery.ps1 b/scripts/volume-discovery.ps1
new file mode 100644
index 0000000..90612a9
--- /dev/null
+++ b/scripts/volume-discovery.ps1
@@ -0,0 +1,61 @@
+# Volume Discovery — Work Orders
+# Executa queries do volume-discovery-report.md contra staging/prod read-only.
+#
+# Uso:
+#   $env:SQL_CONNECTION_STRING = "Server=...;Database=...;User Id=...;Password=...;TrustServerCertificate=True"
+#   .\scripts\volume-discovery.ps1
+
+param(
+    [string]$ConnectionString = $env:SQL_CONNECTION_STRING
+)
+
+function Get-SqlConnectionArgs([string]$cs) {
+    return @("-C", $cs)
+}
+
+if ([string]::IsNullOrWhiteSpace($ConnectionString)) {
+    Write-Error "Defina SQL_CONNECTION_STRING ou passe -ConnectionString."
+    exit 1
+}
+
+$queries = @{
+    TotalWorkOrders = @"
+SELECT COUNT(*) AS TotalWorkOrders
+FROM workOrders
+WHERE IsDeleted IS NULL OR IsDeleted = 0;
+"@
+    P95ProxyMaxPerWeek = @"
+WITH WeeklyCounts AS (
+    SELECT DATEPART(iso_week, ScheduledDate) AS IsoWeek,
+           YEAR(ScheduledDate) AS IsoYear,
+           COUNT(*) AS Cnt
+    FROM workOrders
+    WHERE ScheduledDate IS NOT NULL
+      AND (IsDeleted IS NULL OR IsDeleted = 0)
+    GROUP BY DATEPART(iso_week, ScheduledDate), YEAR(ScheduledDate)
+)
+SELECT MAX(Cnt) AS P95ProxyMaxPerWeek,
+       AVG(Cnt * 1.0) AS AvgPerWeek
+FROM WeeklyCounts;
+"@
+    UnscheduledCount = @"
+SELECT COUNT(*) AS UnscheduledCount
+FROM workOrders
+WHERE ScheduledDate IS NULL
+  AND (IsDeleted IS NULL OR IsDeleted = 0)
+  AND Status NOT IN ('Completed', 'Complete', 'Cancelled', 'Canceled');
+"@
+}
+
+$connArgs = Get-SqlConnectionArgs $ConnectionString
+
+Write-Host "=== Volume Discovery ===" -ForegroundColor Cyan
+Write-Host ""
+
+foreach ($name in $queries.Keys) {
+    Write-Host "--- $name ---" -ForegroundColor Yellow
+    sqlcmd @connArgs -Q $queries[$name] -W
+    Write-Host ""
+}
+
+Write-Host "Preencha docs/work-orders/phase-0/volume-discovery-report.md e docs/work-orders/phase-4/search-tier-decision.md com os resultados."