Refine projected WIP conflict detection

Chris0Jeky · Chris0Jeky · commit 1d75ae9865b4 · 2026-04-27T02:20:23.000+01:00
diff --git a/backend/src/Taskdeck.Application/Services/ProposalConflictDetector.cs b/backend/src/Taskdeck.Application/Services/ProposalConflictDetector.cs
@@ -45,13 +45,13 @@ public async Task<Result<IReadOnlyList<ConflictRowDto>>> DetectConflictsAsync(
         // Entity caches to avoid redundant DB lookups across sub-methods
         var cardCache = new Dictionary<Guid, Card?>();
         var columnCache = new Dictionary<Guid, Column?>();
-        var projectedColumnAdditions = await GetProjectedColumnAdditionCountsAsync(
+        var projectedColumnChanges = await GetProjectedColumnChangesAsync(
             proposal, cardCache, cancellationToken);
 
         // Check each condition and collect rows
         await CheckStaleDataAsync(proposal, rows, flaggedCardIds, cardCache, cancellationToken);
         await CheckWipLimitAsync(proposal, rows, flaggedColumnIds, columnCache,
-            projectedColumnAdditions, cancellationToken);
+            projectedColumnChanges, cancellationToken);
         await CheckDuplicatePendingProposalsAsync(proposal, rows, cancellationToken);
         CheckHighRiskOperations(proposal, rows);
         await CheckOutboundWebhooksAsync(proposal, rows, cancellationToken);
@@ -67,7 +67,7 @@ await CheckWipLimitAsync(proposal, rows, flaggedColumnIds, columnCache,
         {
             // Add positive signals when applicable
             await AddPositiveSignalsAsync(proposal, rows, flaggedCardIds, flaggedColumnIds,
-                cardCache, columnCache, projectedColumnAdditions, cancellationToken);
+                cardCache, columnCache, projectedColumnChanges, cancellationToken);
         }
 
         // Sort: Warn first, then Info, then Ok
@@ -146,17 +146,32 @@ private async Task CheckWipLimitAsync(
         List<ConflictRow> rows,
         HashSet<Guid> flaggedColumnIds,
         Dictionary<Guid, Column?> columnCache,
-        IReadOnlyDictionary<Guid, int> projectedColumnAdditions,
+        IReadOnlyDictionary<Guid, ColumnProjection> projectedColumnChanges,
         CancellationToken cancellationToken)
     {
-        if (projectedColumnAdditions.Count == 0) return;
+        if (projectedColumnChanges.Count == 0) return;
 
-        foreach (var (columnId, additionCount) in projectedColumnAdditions)
+        foreach (var (columnId, projection) in projectedColumnChanges)
         {
             var column = await GetOrFetchColumnAsync(columnId, columnCache, cancellationToken);
-            if (column is null) continue;
+            if (column is null)
+            {
+                if (projection.ReceivesCards)
+                {
+                    flaggedColumnIds.Add(columnId);
+                    rows.Add(new ConflictRow(
+                        ConflictTone.Warn,
+                        "missing-target-column",
+                        $"Target column {columnId:N} no longer exists"));
+                }
+
+                continue;
+            }
+
+            if (!projection.ReceivesCards)
+                continue;
 
-            var projectedCount = column.Cards.Count + additionCount;
+            var projectedCount = column.Cards.Count + projection.Delta;
             if (column.WipLimit.HasValue && projectedCount > column.WipLimit.Value)
             {
                 flaggedColumnIds.Add(columnId);
@@ -299,18 +314,19 @@ private async Task AddPositiveSignalsAsync(
         HashSet<Guid> flaggedColumnIds,
         Dictionary<Guid, Card?> cardCache,
         Dictionary<Guid, Column?> columnCache,
-        IReadOnlyDictionary<Guid, int> projectedColumnAdditions,
+        IReadOnlyDictionary<Guid, ColumnProjection> projectedColumnChanges,
         CancellationToken cancellationToken)
     {
         // Ok: target column has capacity (only if we didn't already warn about WIP for this column)
-        foreach (var (columnId, additionCount) in projectedColumnAdditions)
+        foreach (var (columnId, projection) in projectedColumnChanges)
         {
+            if (!projection.ReceivesCards) continue;
             if (flaggedColumnIds.Contains(columnId)) continue;
 
             var column = await GetOrFetchColumnAsync(columnId, columnCache, cancellationToken);
             if (column is null) continue;
 
-            var projectedCount = column.Cards.Count + additionCount;
+            var projectedCount = column.Cards.Count + projection.Delta;
             if (column.WipLimit.HasValue && projectedCount <= column.WipLimit.Value)
             {
                 rows.Add(new ConflictRow(
@@ -355,15 +371,15 @@ private static List<Guid> GetDistinctCardTargetIds(AutomationProposal proposal,
     }
 
     /// <summary>
-    /// Counts cards each proposal operation would add to a target column.
+    /// Projects card count deltas per column for create/move operations.
     /// Existing cards moved within their current column do not increase projected WIP.
     /// </summary>
-    private async Task<IReadOnlyDictionary<Guid, int>> GetProjectedColumnAdditionCountsAsync(
+    private async Task<IReadOnlyDictionary<Guid, ColumnProjection>> GetProjectedColumnChangesAsync(
         AutomationProposal proposal,
         Dictionary<Guid, Card?> cardCache,
         CancellationToken cancellationToken)
     {
-        var additions = new Dictionary<Guid, int>();
+        var changes = new Dictionary<Guid, ColumnProjection>();
 
         foreach (var op in proposal.Operations)
         {
@@ -374,19 +390,37 @@ private async Task<IReadOnlyDictionary<Guid, int>> GetProjectedColumnAdditionCou
             if (!targetColumnId.HasValue)
                 continue;
 
+            var sourceColumnId = (Guid?)null;
             if (op.ActionType.Equals("move", StringComparison.OrdinalIgnoreCase)
                 && op.TargetType.Equals("card", StringComparison.OrdinalIgnoreCase)
                 && Guid.TryParse(op.TargetId, out var movedCardId))
             {
                 var card = await GetOrFetchCardAsync(movedCardId, cardCache, cancellationToken);
                 if (card?.ColumnId == targetColumnId.Value)
                     continue;
+
+                sourceColumnId = card?.ColumnId;
             }
 
-            additions[targetColumnId.Value] = additions.GetValueOrDefault(targetColumnId.Value) + 1;
+            if (sourceColumnId.HasValue)
+                AddColumnProjectionDelta(changes, sourceColumnId.Value, delta: -1, receivesCards: false);
+
+            AddColumnProjectionDelta(changes, targetColumnId.Value, delta: 1, receivesCards: true);
         }
 
-        return additions;
+        return changes;
+    }
+
+    private static void AddColumnProjectionDelta(
+        Dictionary<Guid, ColumnProjection> changes,
+        Guid columnId,
+        int delta,
+        bool receivesCards)
+    {
+        var existing = changes.GetValueOrDefault(columnId);
+        changes[columnId] = new ColumnProjection(
+            existing.Delta + delta,
+            existing.ReceivesCards || receivesCards);
     }
 
     /// <summary>
@@ -442,6 +476,8 @@ private static bool AddsCardToColumn(AutomationProposalOperation operation)
             || operation.ActionType.Equals("move", StringComparison.OrdinalIgnoreCase);
     }
 
+    private readonly record struct ColumnProjection(int Delta, bool ReceivesCards);
+
     private static IReadOnlyList<string> GetWebhookEventTypes(AutomationProposal proposal)
     {
         return proposal.Operations
diff --git a/backend/tests/Taskdeck.Application.Tests/Services/ProposalConflictDetectorTests.cs b/backend/tests/Taskdeck.Application.Tests/Services/ProposalConflictDetectorTests.cs
@@ -313,6 +313,82 @@ public async Task DetectConflictsAsync_MoveWithinSameColumn_DoesNotIncreaseProje
         result.Value.Should().NotContain(r => r.Key == "wip-limit");
     }
 
+    [Fact]
+    public async Task DetectConflictsAsync_CreateIntoMissingColumn_ReturnsMissingTargetColumnWarning()
+    {
+        var columnId = Guid.NewGuid();
+        var proposal = CreateProposal(_userId, _boardId);
+        proposal.AddOperation(new AutomationProposalOperation(
+            proposal.Id, 0, "create", "column", "{}", Guid.NewGuid().ToString(), columnId.ToString()));
+
+        _proposalRepoMock.Setup(r => r.GetByIdAsync(proposal.Id, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(proposal);
+        _columnRepoMock.Setup(r => r.GetByIdWithCardsAsync(columnId, It.IsAny<CancellationToken>()))
+            .ReturnsAsync((Column?)null);
+        _webhookRepoMock.Setup(r => r.GetActiveByBoardAsync(_boardId, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new List<OutboundWebhookSubscription>());
+
+        var result = await _detector.DetectConflictsAsync(proposal.Id, _userId);
+
+        result.IsSuccess.Should().BeTrue();
+        result.Value.Should().Contain(r =>
+            r.Tone == ConflictTone.Warn
+            && r.Key == "missing-target-column");
+    }
+
+    [Fact]
+    public async Task DetectConflictsAsync_MoveOutAndIntoSameColumn_UsesNetProjectedWip()
+    {
+        var targetColumnId = Guid.NewGuid();
+        var otherColumnId = Guid.NewGuid();
+        var sourceColumnId = Guid.NewGuid();
+        var leavingCardId = Guid.NewGuid();
+        var enteringCardId = Guid.NewGuid();
+
+        var proposal = CreateProposal(_userId, _boardId);
+        proposal.AddOperation(new AutomationProposalOperation(
+            proposal.Id,
+            0,
+            "move",
+            "card",
+            $"{{\"targetColumnId\":\"{otherColumnId}\"}}",
+            Guid.NewGuid().ToString(),
+            leavingCardId.ToString()));
+        proposal.AddOperation(new AutomationProposalOperation(
+            proposal.Id,
+            1,
+            "move",
+            "card",
+            $"{{\"targetColumnId\":\"{targetColumnId}\"}}",
+            Guid.NewGuid().ToString(),
+            enteringCardId.ToString()));
+
+        _proposalRepoMock.Setup(r => r.GetByIdAsync(proposal.Id, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(proposal);
+
+        var targetColumn = new Column(_boardId, "In Progress", 1, wipLimit: 5);
+        AddCardsToColumn(targetColumn, 5);
+        var otherColumn = new Column(_boardId, "Done", 2, wipLimit: 10);
+
+        _columnRepoMock.Setup(r => r.GetByIdWithCardsAsync(targetColumnId, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(targetColumn);
+        _columnRepoMock.Setup(r => r.GetByIdWithCardsAsync(otherColumnId, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(otherColumn);
+
+        _cardRepoMock.Setup(r => r.GetByIdAsync(leavingCardId, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new Card(leavingCardId, _boardId, targetColumnId, "Leaving"));
+        _cardRepoMock.Setup(r => r.GetByIdAsync(enteringCardId, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new Card(enteringCardId, _boardId, sourceColumnId, "Entering"));
+        SetupEmptySecondaryChecks(proposal);
+
+        var result = await _detector.DetectConflictsAsync(proposal.Id, _userId);
+
+        result.IsSuccess.Should().BeTrue();
+        result.Value.Should().NotContain(r =>
+            r.Key == "wip-limit"
+            && r.Value.Contains("In Progress", StringComparison.Ordinal));
+    }
+
     #endregion
 
     #region Warn: Duplicate Pending Proposals
