fix(work-orders): address PR 13/14/15 board review feedback

Tighten board API contracts (BindRequired, ArgumentException to 400, NotFound to 404), share terminal statuses, harden PATCH/create atomicity and vendor validation, restore migration discovery metadata, and cover remaining regression gaps.

Api.SeaHavenIndustries/Controllers/WorkOrderController.cs

@@ -7,6 +7,7 @@ using Microsoft.AspNetCore.Components.Forms;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Identity;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.ModelBinding;
 using Microsoft.Data.SqlClient;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.VisualBasic;
@@ -107,7 +108,7 @@ namespace Api.SeaHavenIndustries.Controllers
 
         [HttpGet("board")]
         public async Task<IActionResult> GetBoard(
-            [FromQuery] DateOnly weekStart,
+            [FromQuery, BindRequired] DateOnly weekStart,
             [FromQuery] DateOnly? weekEnd = null,
             [FromQuery] List<string>? dispatchers = null,
             [FromQuery] bool myWorkOrders = false,
@@ -174,6 +175,14 @@ namespace Api.SeaHavenIndustries.Controllers
                     CurrentState = ex.CurrentState
                 });
             }
+            catch (WorkOrderBoardValidationException ex) when (ex.Code == "NotFound")
+            {
+                return NotFound(new WorkOrderBoardValidationErrorDto
+                {
+                    Code = ex.Code,
+                    Message = ex.Message
+                });
+            }
             catch (WorkOrderBoardValidationException ex)
             {
                 return UnprocessableEntity(new WorkOrderBoardValidationErrorDto
@@ -210,6 +219,14 @@ namespace Api.SeaHavenIndustries.Controllers
                     Message = ex.Message
                 });
             }
+            catch (WorkOrderBoardValidationException ex) when (ex.Code == "NotFound")
+            {
+                return NotFound(new WorkOrderBoardValidationErrorDto
+                {
+                    Code = ex.Code,
+                    Message = ex.Message
+                });
+            }
             catch (WorkOrderBoardValidationException ex)
             {
                 return UnprocessableEntity(new WorkOrderBoardValidationErrorDto
@@ -229,6 +246,14 @@ namespace Api.SeaHavenIndustries.Controllers
                 var row = await _boardCancelService.CancelAsync(id, actorId);
                 return Ok(row);
             }
+            catch (WorkOrderBoardValidationException ex) when (ex.Code == "NotFound")
+            {
+                return NotFound(new WorkOrderBoardValidationErrorDto
+                {
+                    Code = ex.Code,
+                    Message = ex.Message
+                });
+            }
             catch (WorkOrderBoardValidationException ex)
             {
                 return UnprocessableEntity(new WorkOrderBoardValidationErrorDto

Api.SeaHavenIndustries/Filters/ArgumentExceptionFilter.cs

@@ -0,0 +1,21 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Filters;
+
+namespace Api.SeaHavenIndustries.Filters
+{
+    public class ArgumentExceptionFilter : IExceptionFilter
+    {
+        public void OnException(ExceptionContext context)
+        {
+            if (context.Exception is not ArgumentException ex) return;
+
+            context.Result = new BadRequestObjectResult(new
+            {
+                status = "Error",
+                message = ex.Message,
+                code = 400
+            });
+            context.ExceptionHandled = true;
+        }
+    }
+}

Api.SeaHavenIndustries/Program.cs

@@ -29,6 +29,7 @@ builder.Services.AddIdentity<ApplicationUser, IdentityRole>(options =>
 builder.Services.AddControllers(options =>
 {
     options.Filters.Add<Api.SeaHavenIndustries.Filters.ConcurrencyExceptionFilter>();
+    options.Filters.Add<Api.SeaHavenIndustries.Filters.ArgumentExceptionFilter>();
 }).AddJsonOptions(options =>
 {
     options.JsonSerializerOptions.MaxDepth = 264; // or any other desired value

Data.SeaHavenIndustries/Enums/LifecycleStatusSets.cs

@@ -0,0 +1,14 @@
+namespace Data.SeaHavenIndustries.Enums
+{
+    /// <summary>
+    /// Shared terminal lifecycle statuses for EF-translatable filters and board rules.
+    /// </summary>
+    public static class LifecycleStatusSets
+    {
+        public static readonly LifecycleStatus?[] Terminal =
+        {
+            LifecycleStatus.Completed,
+            LifecycleStatus.Canceled
+        };
+    }
+}

Data.SeaHavenIndustries/Migrations/20260619150000_AddWorkOrderTypeAndScheduledDateIndex.cs

@@ -4,7 +4,8 @@ using Microsoft.EntityFrameworkCore.Migrations;
 
 namespace Data.SeaHavenIndustries.Migrations
 {
-    public class AddWorkOrderTypeAndScheduledDateIndex : Migration
+    /// <inheritdoc />
+    public partial class AddWorkOrderTypeAndScheduledDateIndex : Migration
     {
         protected override void Up(MigrationBuilder migrationBuilder)
         {

Data.SeaHavenIndustries/Migrations/20260701120000_Phase1_BoardIndexes.cs

@@ -5,7 +5,7 @@ using Microsoft.EntityFrameworkCore.Migrations;
 namespace Data.SeaHavenIndustries.Migrations
 {
     /// <inheritdoc />
-    public class Phase1_BoardIndexes : Migration
+    public partial class Phase1_BoardIndexes : Migration
     {
         /// <inheritdoc />
         protected override void Up(MigrationBuilder migrationBuilder)

SeaHaven.DataServices/Board/WorkOrderBoardConstants.cs

@@ -1,7 +0,0 @@
-namespace SeaHaven.DataServices.Board
-{
-    public static class WorkOrderBoardConstants
-    {
-        public const int ClientSideThreshold = 300;
-    }
-}

SeaHaven.DataServices/DTOs/WorkOrderBoardQuery.cs

@@ -1,10 +0,0 @@
-namespace SeaHaven.DataServices.DTOs
-{
-    public record WorkOrderBoardQuery(
-        DateOnly ScheduledFrom,
-        DateOnly ScheduledTo,
-        string? Search,
-        IReadOnlyList<string>? AssigneeIds,
-        IReadOnlyList<string>? DbStatuses,
-        int? LocationId);
-}

SeaHaven.DataServices/DTOs/WorkOrderBoardRowData.cs

@@ -1,20 +0,0 @@
-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);
-}

SeaHaven.DataServices/Implementation/WorkOrderBoardDataService.cs

@@ -31,10 +31,10 @@ namespace SeaHaven.DataServices.Implementation
                  && w.ScheduledDate.Value.Date <= weekEndDate.Date)
                 || (w.ScheduleWeekOnly == true && w.TargetWeek == query.WeekStart));
 
+            var terminalStatuses = LifecycleStatusSets.Terminal;
             var unscheduledBase = baseQuery.Where(w =>
                 w.ScheduledDate == null
-                && w.LifecycleStatus != LifecycleStatus.Completed
-                && w.LifecycleStatus != LifecycleStatus.Canceled);
+                && !terminalStatuses.Contains(w.LifecycleStatus));
 
             var scheduledTotal = await scheduledBase.CountAsync();
 

SeaHaven.DataServices/Implementation/WorkOrderDomainJobDataService.cs

@@ -7,12 +7,6 @@ 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)
@@ -39,7 +33,7 @@ namespace SeaHaven.DataServices.Implementation
                 .Where(w =>
                     w.ScheduledDate!.Value.Date >= weekStartDate.Date
                     && w.ScheduledDate.Value.Date <= weekEndDate.Date)
-                .Where(w => !TerminalStatuses.Contains(w.LifecycleStatus))
+                .Where(w => !LifecycleStatusSets.Terminal.Contains(w.LifecycleStatus))
                 .Where(w => !_context.WorkOrderWeekRolledLedgers.Any(l =>
                     l.WorkOrderId == w.Id && l.SourceWeekStart == sourceWeekStart))
                 .OrderBy(w => w.Id)
@@ -133,7 +127,7 @@ namespace SeaHaven.DataServices.Implementation
                 {
                     examinedCount++;
                     var shouldBePastDue = workOrder.ScheduledDate!.Value.Date < today
-                        && !TerminalStatuses.Contains(workOrder.LifecycleStatus);
+                        && !LifecycleStatusSets.Terminal.Contains(workOrder.LifecycleStatus);
                     var hasFlag = workOrder.OperationalFlags.HasFlag(OperationalFlags.PastDue);
 
                     if (shouldBePastDue && !hasFlag)

SeaHaven.Services/Helpers/WorkOrderBoardFieldMutations.cs

@@ -64,7 +64,11 @@ namespace SeaHaven.Services.Helpers
         public static List<BoardFieldChange> ApplyAutoScheduleSideEffects(WorkOrder workOrder)
         {
             var changes = new List<BoardFieldChange>();
-            if (!WorkOrderBoardMutationRules.ShouldAutoSchedule(workOrder.LifecycleStatus, workOrder.ScheduledDate, workOrder.AssignTo))
+            if (!WorkOrderBoardMutationRules.ShouldAutoSchedule(
+                    workOrder.LifecycleStatus,
+                    workOrder.ScheduledDate,
+                    workOrder.AssignTo,
+                    workOrder.ScheduleWeekOnly))
                 return changes;
 
             var old = workOrder.LifecycleStatus?.ToString();

SeaHaven.Services/Helpers/WorkOrderBoardMutationRules.cs

@@ -4,22 +4,25 @@ namespace SeaHaven.Services.Helpers
 {
     public static class WorkOrderBoardMutationRules
     {
-        private static readonly HashSet<LifecycleStatus?> ReadOnlyStatuses = new()
-        {
-            LifecycleStatus.Canceled,
-            LifecycleStatus.Completed
-        };
+        private static readonly HashSet<LifecycleStatus?> ReadOnlyStatuses =
+            LifecycleStatusSets.Terminal.ToHashSet();
 
         public static bool IsReadOnly(LifecycleStatus? status) => ReadOnlyStatuses.Contains(status);
 
         public static bool ShouldBlockStatusChangeWhenPastDue(string field, bool isPastDue)
             => field.Equals(WorkOrderBoardFieldNames.LifecycleStatus, StringComparison.OrdinalIgnoreCase) && isPastDue;
 
+        /// <summary>
+        /// SHOC rule: Incomplete + specific scheduled date + assignee → Scheduled.
+        /// Week-only targets do not auto-schedule (same as <see cref="WorkOrderDerivedFields.ApplyAutoScheduleIfEligible"/>).
+        /// </summary>
         public static bool ShouldAutoSchedule(
             LifecycleStatus? status,
             DateTime? scheduledDate,
-            string? assignTo)
+            string? assignTo,
+            bool? scheduleWeekOnly = null)
             => status == LifecycleStatus.Incomplete
+               && scheduleWeekOnly != true
                && scheduledDate.HasValue
                && !string.IsNullOrWhiteSpace(assignTo);
 

SeaHaven.Services/Implementation/WorkOrderBoardCreateService.cs

@@ -173,29 +173,47 @@ namespace SeaHaven.Services.Implementation
                     changes.Add(WorkOrderBoardFieldMutations.BoardFieldChange.Changed("VendorNotes", "", vendorNotes));
             }
 
-            _context.workOrders.Add(workOrder);
-            await _context.SaveChangesAsync();
+            // Two SaveChanges are required so generated WO/dispatch IDs can backfill FKs and
+            // audit/lock/contact rows. A transaction keeps the create atomic across both saves.
+            await using var transaction = _context.Database.IsRelational()
+                ? await _context.Database.BeginTransactionAsync()
+                : null;
 
-            if (dispatch != null && workOrder.PrimaryDispatchId == null)
+            try
             {
-                workOrder.PrimaryDispatchId = dispatch.Id;
-                dispatch.WorkOrderId = workOrder.Id;
-            }
+                _context.workOrders.Add(workOrder);
+                await _context.SaveChangesAsync();
 
-            _auditService.StageCreated(workOrder.Id, actorId, woNumber);
-            StageChanges(workOrder.Id, changes, actorId, dispatch);
-
-            if (request.PocContactId.HasValue)
-            {
-                _context.WorkOrderContacts.Add(new WorkOrderContacts
+                if (dispatch != null && workOrder.PrimaryDispatchId == null)
                 {
-                    WorkorderId = workOrder.Id,
-                    ContactId = request.PocContactId,
-                    Notes = pocNotes
-                });
-            }
+                    workOrder.PrimaryDispatchId = dispatch.Id;
+                    dispatch.WorkOrderId = workOrder.Id;
+                }
 
-            await _context.SaveChangesAsync();
+                _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();
+
+                if (transaction is not null)
+                    await transaction.CommitAsync();
+            }
+            catch
+            {
+                if (transaction is not null)
+                    await transaction.RollbackAsync();
+                throw;
+            }
 
             var row = await _boardService.GetBoardRowAsync(workOrder.Id);
             return row ?? throw new WorkOrderBoardValidationException("NotFound", "Work order was created but could not be loaded.");

SeaHaven.Services/Implementation/WorkOrderBoardUpdateService.cs

@@ -31,109 +31,136 @@ namespace SeaHaven.Services.Implementation
             WorkOrderBoardPatchRequestDto request,
             string? actorId)
         {
-            if (string.IsNullOrWhiteSpace(request.Field))
-                throw new WorkOrderBoardValidationException("InvalidField", "Field is required.");
+            // Intermediate SaveChanges (e.g. new dispatch identity) must stay atomic with the final patch save.
+            await using var transaction = _context.Database.IsRelational()
+                ? await _context.Database.BeginTransactionAsync()
+                : null;
 
-            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))
+            try
             {
-                var staleState = await LoadBoardRowAsync(workOrderId);
-                throw new WorkOrderBoardConcurrencyException(staleState);
-            }
+                if (string.IsNullOrWhiteSpace(request.Field))
+                    throw new WorkOrderBoardValidationException("InvalidField", "Field is required.");
 
-            if (WorkOrderBoardMutationRules.IsReadOnly(workOrder.LifecycleStatus))
-                throw new WorkOrderBoardValidationException("CanceledReadOnly", "Work order is read-only in its current status.");
+                var field = request.Field.Trim();
+                var canonicalField = WorkOrderBoardFieldNames.Canonicalize(field);
+                if (canonicalField == null)
+                    throw new WorkOrderBoardValidationException("InvalidField", $"Field '{field}' is not editable.");
 
-            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.");
+                var workOrderVersion = ParseRowVersion(request.WorkOrderVersion, "workOrderVersion");
+                if (workOrderVersion == null)
+                    throw new WorkOrderBoardValidationException("WorkOrderVersionRequired", "workOrderVersion is required.");
 
-            _context.Entry(workOrder).Property(w => w.RowVersion).OriginalValue = workOrderVersion;
+                var dispatchVersion = ParseRowVersion(request.DispatchVersion, "dispatchVersion");
 
-            Dispatch? dispatch = null;
-            if (WorkOrderBoardFieldNames.IsDispatchField(canonicalField))
-            {
-                var vendorIdHint = canonicalField.Equals(WorkOrderBoardFieldNames.VendorId, StringComparison.OrdinalIgnoreCase)
-                    ? ParseVendorIdHint(request.Value)
-                    : null;
+                var workOrder = await _context.workOrders
+                    .FirstOrDefaultAsync(w => w.Id == workOrderId && w.istemplate != true && (w.IsDeleted != true || w.IsDeleted == null));
 
-                var hadPrimaryDispatch = workOrder.PrimaryDispatchId.HasValue;
-                dispatch = await ResolveDispatchAsync(workOrder, request.PrimaryDispatchId, vendorIdHint);
+                if (workOrder == null)
+                    throw new WorkOrderBoardValidationException("NotFound", "Work order not found.");
 
-                if (dispatchVersion != null && !RowVersionsMatch(dispatch.RowVersion, dispatchVersion))
+                if (!RowVersionsMatch(workOrder.RowVersion, workOrderVersion))
                 {
                     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.");
-            }
+                if (WorkOrderBoardMutationRules.IsReadOnly(workOrder.LifecycleStatus))
+                    throw new WorkOrderBoardValidationException("CanceledReadOnly", "Work order is read-only in its current status.");
 
-            var auditField = WorkOrderBoardFieldNames.ToAuditFieldName(canonicalField);
-            var changes = await ApplyFieldMutationAsync(canonicalField, workOrder, dispatch, request.Value, auditField);
-            changes = changes.Where(c => c.HasChanged).ToList();
+                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.");
 
-            if (changes.Count == 0 && !_context.ChangeTracker.HasChanges())
-            {
-                var unchanged = await LoadBoardRowAsync(workOrderId);
-                return unchanged ?? throw new WorkOrderBoardValidationException("NotFound", "Work order not found.");
-            }
+                _context.Entry(workOrder).Property(w => w.RowVersion).OriginalValue = workOrderVersion;
 
-            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)
+                Dispatch? dispatch = null;
+                if (WorkOrderBoardFieldNames.IsDispatchField(canonicalField))
                 {
-                    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;
+                    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.");
                 }
-            }
 
-            try
-            {
-                await _context.SaveChangesAsync();
-            }
-            catch (DbUpdateConcurrencyException)
-            {
-                _context.ChangeTracker.Clear();
-                var currentState = await LoadBoardRowAsync(workOrderId);
-                throw new WorkOrderBoardConcurrencyException(currentState);
-            }
+                var auditField = WorkOrderBoardFieldNames.ToAuditFieldName(canonicalField);
+                var changes = await ApplyFieldMutationAsync(canonicalField, workOrder, dispatch, request.Value, auditField);
+                changes = changes.Where(c => c.HasChanged).ToList();
 
-            var row = await LoadBoardRowAsync(workOrderId);
-            return row ?? throw new WorkOrderBoardValidationException("NotFound", "Work order not found.");
+                if (changes.Count == 0 && !_context.ChangeTracker.HasChanges())
+                {
+                    var unchanged = await LoadBoardRowAsync(workOrderId);
+                    if (transaction is not null)
+                        await transaction.CommitAsync();
+                    return unchanged ?? throw new WorkOrderBoardValidationException("NotFound", "Work order not found.");
+                }
+
+                if (changes.Count == 0)
+                {
+                    await _context.SaveChangesAsync();
+                    if (transaction is not null)
+                        await transaction.CommitAsync();
+                    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)
+                {
+                    if (transaction is not null)
+                        await transaction.RollbackAsync();
+                    _context.ChangeTracker.Clear();
+                    var currentState = await LoadBoardRowAsync(workOrderId);
+                    throw new WorkOrderBoardConcurrencyException(currentState);
+                }
+
+                if (transaction is not null)
+                    await transaction.CommitAsync();
+
+                var row = await LoadBoardRowAsync(workOrderId);
+                return row ?? throw new WorkOrderBoardValidationException("NotFound", "Work order not found.");
+            }
+            catch (WorkOrderBoardConcurrencyException)
+            {
+                throw;
+            }
+            catch
+            {
+                if (transaction is not null)
+                    await transaction.RollbackAsync();
+                throw;
+            }
         }
 
         private async Task<List<FieldChange>> ApplyFieldMutationAsync(
@@ -154,7 +181,7 @@ namespace SeaHaven.Services.Implementation
                 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.VendorId => new List<FieldChange> { await ApplyVendorIdAsync(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) },
@@ -192,6 +219,8 @@ namespace SeaHaven.Services.Implementation
             if (!vendorIdForCreate.HasValue || vendorIdForCreate.Value <= 0)
                 throw new WorkOrderBoardValidationException("DispatchRequired", "A primary dispatch is required. Set vendorId first or provide primaryDispatchId.");
 
+            await EnsureVendorExistsAsync(vendorIdForCreate.Value);
+
             var created = new Dispatch
             {
                 WorkOrderId = workOrder.Id,
@@ -205,6 +234,13 @@ namespace SeaHaven.Services.Implementation
             return created;
         }
 
+        private async Task EnsureVendorExistsAsync(int vendorId)
+        {
+            var vendorExists = await _context.Vendors.AnyAsync(v => v.Id == vendorId && v.IsDeleted != true);
+            if (!vendorExists)
+                throw new WorkOrderBoardValidationException("VendorNotFound", "vendorId does not exist.");
+        }
+
         private async Task<FieldChange> ApplyWoNumber(WorkOrder workOrder, string? value, string auditField)
         {
             if (!WorkOrderNumberNormalizer.TryNormalize(value, out var normalized, out var error))
@@ -477,12 +513,14 @@ namespace SeaHaven.Services.Implementation
             return FieldChange.ForField(auditField, old, parsed.ToString());
         }
 
-        private static FieldChange ApplyVendorId(Dispatch dispatch, string? value, string auditField)
+        private async Task<FieldChange> ApplyVendorIdAsync(Dispatch dispatch, string? value, string auditField)
         {
             var vendorId = ParseVendorIdHint(value);
             if (!vendorId.HasValue)
                 throw new WorkOrderBoardValidationException("InvalidValue", "vendorId must be a positive integer.");
 
+            await EnsureVendorExistsAsync(vendorId.Value);
+
             var old = dispatch.VendorId.ToString();
             if (dispatch.VendorId == vendorId.Value)
                 return FieldChange.Unchanged(auditField, dispatch.Id);
@@ -570,7 +608,11 @@ namespace SeaHaven.Services.Implementation
         private static List<FieldChange> ApplyAutoScheduleSideEffects(WorkOrder workOrder)
         {
             var changes = new List<FieldChange>();
-            if (!WorkOrderBoardMutationRules.ShouldAutoSchedule(workOrder.LifecycleStatus, workOrder.ScheduledDate, workOrder.AssignTo))
+            if (!WorkOrderBoardMutationRules.ShouldAutoSchedule(
+                    workOrder.LifecycleStatus,
+                    workOrder.ScheduledDate,
+                    workOrder.AssignTo,
+                    workOrder.ScheduleWeekOnly))
                 return changes;
 
             var old = workOrder.LifecycleStatus?.ToString();

SeaHavenIndustries.Tests/WorkOrderBoardCreateRelationalTests.cs

@@ -67,6 +67,61 @@ public class WorkOrderBoardCreateRelationalTests
         Assert.DoesNotContain(locks, l => l.WorkOrderId == 0);
     }
 
+    [Fact]
+    public async Task Create_WhenContactPersistenceFails_RollsBackWorkOrder()
+    {
+        await using var connection = new SqliteConnection("DataSource=:memory:");
+        await connection.OpenAsync();
+
+        var options = new DbContextOptionsBuilder<ApplicationDbContext>()
+            .UseSqlite(connection)
+            .Options;
+
+        await using (var seedContext = new SqliteBoardTestDbContext(options))
+        {
+            await seedContext.Database.EnsureCreatedAsync();
+            seedContext.Users.Add(new ApplicationUser
+            {
+                Id = "actor-1",
+                UserName = "actor-1",
+                NormalizedUserName = "ACTOR-1",
+                Email = "actor@test.local",
+                NormalizedEmail = "ACTOR@TEST.LOCAL"
+            });
+            await seedContext.SaveChangesAsync();
+        }
+
+        await using (var context = new SqliteBoardTestDbContext(options))
+        {
+            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());
+
+            await Assert.ThrowsAsync<DbUpdateException>(() =>
+                service.CreateAsync(new WorkOrderBoardCreateRequestDto
+                {
+                    WorkOrderType = WorkOrderType.PM,
+                    SiteCode = "BK5",
+                    Description = "Should roll back",
+                    PocContactId = 999_999
+                }, "actor-1"));
+        }
+
+        await using var verify = new SqliteBoardTestDbContext(options);
+        Assert.Empty(await verify.workOrders.AsNoTracking().ToListAsync());
+        Assert.Empty(await verify.WorkOrderAuditLogs.AsNoTracking().ToListAsync());
+        Assert.Empty(await verify.WorkOrderFieldLocks.AsNoTracking().ToListAsync());
+        Assert.Empty(await verify.WorkOrderContacts.AsNoTracking().ToListAsync());
+        Assert.Empty(await verify.Dispatches.AsNoTracking().ToListAsync());
+    }
+
     private sealed class SqliteBoardTestDbContext : ApplicationDbContext
     {
         public SqliteBoardTestDbContext(DbContextOptions<ApplicationDbContext> options)

SeaHavenIndustries.Tests/WorkOrderBoardMutationRulesTests.cs

@@ -42,6 +42,16 @@ public class WorkOrderBoardMutationRulesTests
             "dispatcher-1"));
     }
 
+    [Fact]
+    public void ShouldAutoSchedule_FalseWhenScheduleWeekOnly()
+    {
+        Assert.False(WorkOrderBoardMutationRules.ShouldAutoSchedule(
+            LifecycleStatus.Incomplete,
+            new DateTime(2026, 6, 25),
+            "dispatcher-1",
+            scheduleWeekOnly: true));
+    }
+
     [Fact]
     public void IsReschedule_WhenPreviousDateExistsAndChanges()
     {

SeaHavenIndustries.Tests/WorkOrderBoardUpdateServiceTests.cs

@@ -503,4 +503,184 @@ public class WorkOrderBoardUpdateServiceTests
 
         Assert.Equal("#8B5CF6", result.FlagColor);
     }
+
+    [Fact]
+    public async Task PatchField_WeekOnly_DoesNotAutoScheduleOnAssignTo()
+    {
+        var (context, service) = CreateSut();
+        var wo = new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Incomplete,
+            ScheduledDate = new DateTime(2026, 6, 25),
+            ScheduleWeekOnly = true,
+            TargetWeek = new DateOnly(2026, 6, 22),
+            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.AssignTo,
+            Value = "user-a",
+            WorkOrderVersion = ToVersion(wo)
+        }, "actor-1");
+
+        Assert.Equal(LifecycleStatus.Incomplete, result.LifecycleStatus);
+        Assert.Equal("user-a", result.DispatcherId);
+    }
+
+    [Fact]
+    public async Task PatchField_ApptTime_UpdatesScheduledStart()
+    {
+        var (context, service) = CreateSut();
+        var dispatch = new Dispatch
+        {
+            Id = 10,
+            WorkOrderId = 1,
+            VendorId = 1,
+            ScheduledDate = new DateTime(2026, 6, 25),
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 2 }
+        };
+        var wo = new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Scheduled,
+            PrimaryDispatchId = 10,
+            ScheduledDate = new DateTime(2026, 6, 25),
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        };
+        context.Vendors.Add(new Vendor { Id = 1, CompanyName = "Vendor A" });
+        context.Dispatches.Add(dispatch);
+        context.workOrders.Add(wo);
+        await context.SaveChangesAsync();
+
+        var result = await service.PatchFieldAsync(1, new WorkOrderBoardPatchRequestDto
+        {
+            Field = WorkOrderBoardFieldNames.ApptTime,
+            Value = "09:00-10:00",
+            WorkOrderVersion = ToVersion(wo),
+            DispatchVersion = ToVersion(dispatch),
+            PrimaryDispatchId = 10
+        }, "actor-1");
+
+        Assert.Contains("09:00", result.ApptTime);
+        var reloaded = await context.workOrders.FindAsync(1);
+        Assert.Equal(new DateTime(2026, 6, 25, 9, 0, 0), reloaded!.ScheduledStart);
+        Assert.Equal(new DateTime(2026, 6, 25, 10, 0, 0), reloaded.ScheduledEnd);
+    }
+
+    [Fact]
+    public async Task PatchField_ApptTime_DashPrefixedToken_TreatedAsSingleStart()
+    {
+        // "-30" splits on '-' into ["30"], which TimeSpan.TryParse accepts as 30.0:00:00 (30 days).
+        var (context, service) = CreateSut();
+        var dispatch = new Dispatch
+        {
+            Id = 10,
+            WorkOrderId = 1,
+            VendorId = 1,
+            ScheduledDate = new DateTime(2026, 6, 25),
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 2 }
+        };
+        var wo = new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Scheduled,
+            PrimaryDispatchId = 10,
+            ScheduledDate = new DateTime(2026, 6, 25),
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        };
+        context.Vendors.Add(new Vendor { Id = 1, CompanyName = "Vendor A" });
+        context.Dispatches.Add(dispatch);
+        context.workOrders.Add(wo);
+        await context.SaveChangesAsync();
+
+        await service.PatchFieldAsync(1, new WorkOrderBoardPatchRequestDto
+        {
+            Field = WorkOrderBoardFieldNames.ApptTime,
+            Value = "-30",
+            WorkOrderVersion = ToVersion(wo),
+            DispatchVersion = ToVersion(dispatch),
+            PrimaryDispatchId = 10
+        }, "actor-1");
+
+        var reloaded = await context.workOrders.FindAsync(1);
+        Assert.NotNull(reloaded!.ScheduledStart);
+        // CombineDateAndTime returns the date alone when time is null, so end becomes midnight.
+        Assert.Equal(new DateTime(2026, 6, 25), reloaded.ScheduledEnd);
+        Assert.Equal(new DateTime(2026, 6, 25).Add(TimeSpan.FromDays(30)), reloaded.ScheduledStart);
+    }
+
+    [Fact]
+    public async Task PatchField_DispatchFieldWithoutVersion_ThrowsDispatchVersionRequired()
+    {
+        var (context, service) = CreateSut();
+        var dispatch = new Dispatch
+        {
+            Id = 10,
+            WorkOrderId = 1,
+            VendorId = 1,
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 2 }
+        };
+        var wo = new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Scheduled,
+            PrimaryDispatchId = 10,
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        };
+        context.Vendors.Add(new Vendor { Id = 1, CompanyName = "Vendor A" });
+        context.Dispatches.Add(dispatch);
+        context.workOrders.Add(wo);
+        await context.SaveChangesAsync();
+
+        var ex = await Assert.ThrowsAsync<WorkOrderBoardValidationException>(() =>
+            service.PatchFieldAsync(1, new WorkOrderBoardPatchRequestDto
+            {
+                Field = WorkOrderBoardFieldNames.ApptDate,
+                Value = "2026-06-26",
+                WorkOrderVersion = ToVersion(wo),
+                PrimaryDispatchId = 10
+            }, "actor-1"));
+
+        Assert.Equal("DispatchVersionRequired", ex.Code);
+    }
+
+    [Fact]
+    public async Task PatchField_VendorIdNotFound_Throws()
+    {
+        var (context, service) = CreateSut();
+        var dispatch = new Dispatch
+        {
+            Id = 10,
+            WorkOrderId = 1,
+            VendorId = 1,
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 2 }
+        };
+        var wo = new WorkOrder
+        {
+            Id = 1,
+            LifecycleStatus = LifecycleStatus.Scheduled,
+            PrimaryDispatchId = 10,
+            RowVersion = new byte[] { 1, 0, 0, 0, 0, 0, 0, 1 }
+        };
+        context.Vendors.Add(new Vendor { Id = 1, CompanyName = "Vendor A" });
+        context.Dispatches.Add(dispatch);
+        context.workOrders.Add(wo);
+        await context.SaveChangesAsync();
+
+        var ex = await Assert.ThrowsAsync<WorkOrderBoardValidationException>(() =>
+            service.PatchFieldAsync(1, new WorkOrderBoardPatchRequestDto
+            {
+                Field = WorkOrderBoardFieldNames.VendorId,
+                Value = "999",
+                WorkOrderVersion = ToVersion(wo),
+                DispatchVersion = ToVersion(dispatch),
+                PrimaryDispatchId = 10
+            }, "actor-1"));
+
+        Assert.Equal("VendorNotFound", ex.Code);
+    }
 }

docs/work-orders/phase-1/README.md

@@ -17,10 +17,10 @@ Retorna WOs agendadas na semana + seção **Unscheduled** em uma única chamada.
 
 | 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` |
+| `weekStart` | Sim (`BindRequired`) | Segunda-feira da semana (`YYYY-MM-DD`). Omitir retorna **400**. |
+| `weekEnd` | Não | Default: `weekStart + 4 dias` (sexta). Janela pode ter até 7 dias. |
+| `dispatchers` | Não | Lista de GUIDs; use `__unassigned__` para não atribuídos. **Ignorado** quando `myWorkOrders=true`. |
+| `myWorkOrders` | Não | `true` → filtra `AssignTo == usuário logado` e tem **precedência** sobre `dispatchers` (não é AND). |
 | `types` | Não | Valores enum `WorkOrderType` (`PM`, `PO`, `Emergency`, etc.) |
 | `search` | Não | Busca contextual (site, WO#, location, dispatcher, trade, vendor, status) |
 
@@ -45,10 +45,14 @@ curl -H "Authorization: Bearer <token>" \
 
 - `counts.total` — WOs agendadas na semana (filtros dispatcher/tipo, **sem** search)
 - `counts.returned` — WOs agendadas após aplicar search
+- `dayGroup` — `monday`…`friday` para dias úteis; **`null` no sábado/domingo** (a janela pode incluir fim de semana; o FE deve tratar `dayGroup` nulo)
+- Referência de dia / past-due: **UTC** nesta fase (timezone de negócio fica para fase posterior)
 
 ### `GET /api/workorders/lookups/dispatchers`
 
-Lista dispatchers para filtros do board.
+Lista opções para o filtro/dropdown de assignee do board.
+
+**Escopo atual (placeholder):** todos os users com `IsDeleted != true` — ainda **sem** filtro por role. Quando roles de assignee estiverem definidos, este lookup será restrito.
 
 ```json
 [