SEK-G30: distinguish unspecified tag reservations (#1120)

* dcb: distinguish unspecified tag reservations

* test: kill nonempty reservation collapse

Author: tomohisa

dcb/src/Sekiban.Dcb.Core/Actors/CoreGeneralSekibanExecutor.cs

@@ -153,7 +153,7 @@ public async Task<ResultBox<ExecutionResult>> ExecuteAsync<TCommand>(
                     continue; // skip non-consistency tags (no reservation)
                 }
 
-                var lastSortableUniqueId = "";
+                string? lastSortableUniqueId = null;
 
                 if (tag is ConsistencyTag ctWithVersion && ctWithVersion.SortableUniqueId.HasValue)
                 {
@@ -381,15 +381,23 @@ public async Task<ResultBox<SerializableTagState>> GetSerializableTagStateAsync(
         }
     }
 
-    public async Task<ResultBox<SerializedCommitResult>> CommitSerializableEventsAsync(
-        SerializedCommitRequest request,
-        CancellationToken cancellationToken)
+    public async Task<ResultBox<SerializedCommitResult>> CommitSerializableEventsAsync(
+        SerializedCommitRequest request,
+        CancellationToken cancellationToken)
     {
         var stopwatch = Stopwatch.StartNew();
 
-        try
-        {
-            if (request.EventCandidates.Count == 0)
+        try
+        {
+            if (request.ConsistencyTags.Any(entry => entry.LastSortableUniqueId is null))
+            {
+                return ResultBox.Error<SerializedCommitResult>(
+                    new ArgumentException(
+                        "Serialized consistency-tag reservations require a non-null lastSortableUniqueId. " +
+                        "Use an empty string to assert that the tag is empty."));
+            }
+
+            if (request.EventCandidates.Count == 0)
             {
                 return ResultBox.FromValue(
                     new SerializedCommitResult(

dcb/src/Sekiban.Dcb.Core/Actors/GeneralTagConsistentActor.cs

@@ -66,7 +66,7 @@ public async Task<ResultBox<string>> GetLatestSortableUniqueIdAsync()
         }
     }
 
-    public async Task<ResultBox<TagWriteReservation>> MakeReservationAsync(string lastSortableUniqueId)
+    public async Task<ResultBox<TagWriteReservation>> MakeReservationAsync(string? lastSortableUniqueId)
     {
         // Ensure catch-up is completed before acquiring lock
         await EnsureCatchUpCompletedAsync();
@@ -85,9 +85,16 @@ public async Task<ResultBox<TagWriteReservation>> MakeReservationAsync(string la
                     new Exception($"Tag {await GetTagActorIdAsync()} is currently reserved"));
             }
 
-            // SEK-G19: EXACT-MATCH optimistic-concurrency check after null/empty NORMALIZATION, in-lock and post-catch-up. An
+            // SEK-G30: null means the command never observed this tag. Keep the complete reservation lifecycle, but do
+            // not compare, refresh, or adopt a version. Empty remains G19 AssertEmpty and non-empty remains ExactMatch.
+            if (lastSortableUniqueId is null)
+            {
+                return ResultBox.FromValue(await CreateReservationAsync());
+            }
+
+            // SEK-G19: EXACT-MATCH optimistic-concurrency check after the SEK-G30 null branch, in-lock and post-catch-up. An
             // empty caller version means "I expect this tag to be EMPTY" (a first write) — NOT "skip the check". Comparing
-            // the normalized expected against the normalized current (both null/empty collapse to "") covers all five
+            // empty expected/current values normalized to "" covers all five
             // classes: empty/empty pass (first write on an empty tag); empty/non-empty CONFLICT (a second first-write against
             // a tag that already has committed state — the #1085 hole); non-empty/empty CONFLICT (an update expecting a
             // version the tag never had — the secondary hole); non-empty mismatch CONFLICT; non-empty match pass. The
@@ -131,24 +138,26 @@ public async Task<ResultBox<TagWriteReservation>> MakeReservationAsync(string la
                 _latestSortableUniqueId = lastSortableUniqueId;
             }
 
-            // Create new reservation
-            var reservationCode = Guid.NewGuid().ToString();
-            var expiredUtc = DateTime.UtcNow.AddSeconds(_options.CancellationWindowSeconds);
-            var reservation = new TagWriteReservation(
-                reservationCode,
-                expiredUtc.ToString("yyyy-MM-dd'T'HH:mm:ss.fffffff'Z'"),
-                await GetTagActorIdAsync());
-
-            _activeReservations[reservationCode] = reservation;
-
-            return ResultBox.FromValue(reservation);
+            return ResultBox.FromValue(await CreateReservationAsync());
         }
         finally
         {
             _reservationLock.Release();
         }
     }
 
+    private async Task<TagWriteReservation> CreateReservationAsync()
+    {
+        var reservationCode = Guid.NewGuid().ToString();
+        var expiredUtc = DateTime.UtcNow.AddSeconds(_options.CancellationWindowSeconds);
+        var reservation = new TagWriteReservation(
+            reservationCode,
+            expiredUtc.ToString("yyyy-MM-dd'T'HH:mm:ss.fffffff'Z'"),
+            await GetTagActorIdAsync());
+        _activeReservations[reservationCode] = reservation;
+        return reservation;
+    }
+
     /// <summary>
     ///     Performs the bounded SEK-G22 authoritative re-check while <see cref="_reservationLock" /> is already held.
     ///     This method deliberately does not call the catch-up path or acquire the reservation lock.

dcb/src/Sekiban.Dcb.Core/Actors/ITagConsistentActorCommon.cs

@@ -18,7 +18,10 @@ public interface ITagConsistentActorCommon
     /// <returns>ResultBox containing the latest sortable unique ID (empty string if none) or error if something went wrong</returns>
     Task<ResultBox<string>> GetLatestSortableUniqueIdAsync();
 
-    Task<ResultBox<TagWriteReservation>> MakeReservationAsync(string lastSortableUniqueId);
+    /// <param name="lastSortableUniqueId">
+    ///     null for an unobserved tag (reserve without comparison), empty to assert empty, or a non-empty exact version.
+    /// </param>
+    Task<ResultBox<TagWriteReservation>> MakeReservationAsync(string? lastSortableUniqueId);
     Task<bool> ConfirmReservationAsync(TagWriteReservation reservation);
     Task<bool> CancelReservationAsync(TagWriteReservation reservation);
 

dcb/src/Sekiban.Dcb.Core/Actors/TagReservationHelper.cs

@@ -12,7 +12,7 @@ public static class TagReservationHelper
     public static async Task<ResultBox<TagWriteReservation>> RequestReservationAsync(
         IActorObjectAccessor actorAccessor,
         ITag tag,
-        string lastSortableUniqueId)
+        string? lastSortableUniqueId)
     {
         try
         {

dcb/src/Sekiban.Dcb.Core/Commands/ConsistencyTagEntry.cs

@@ -1,7 +1,8 @@
 namespace Sekiban.Dcb.Commands;
 
 /// <summary>
-///     Consistency check DTO: tag string + last SortableUniqueId for reservation.
+///     Consistency check DTO: tag string + last SortableUniqueId for reservation. Empty asserts that the tag is empty;
+///     null is invalid on the legacy/V1 serialized boundary.
 ///     Used by WASM clients to specify which tags require consistency checks.
 /// </summary>
 public record ConsistencyTagEntry(

dcb/src/Sekiban.Dcb.Core/Commands/CoreGeneralCommandContext.cs

@@ -215,13 +215,12 @@ public async Task<ResultBox<bool>> TagExistsAsync(ITag tag)
                 // a first write still reserves expect-empty and a second first-write conflicts (the #1085 fix is preserved).
                 if (!_accessedTagStates.ContainsKey(tag))
                 {
-                    var tagContent = tag.GetTag().Substring(tag.GetTagGroup().Length + 1);
-                    _accessedTagStates[tag] = new TagState(
-                        new EmptyTagStatePayload(), 0, latestSortableUniqueId, tag.GetTagGroup(), tagContent, string.Empty, string.Empty);
+                    TrackObservedVersion(tag, latestSortableUniqueId);
                 }
                 return ResultBox.FromValue(true);
             }
 
+            TrackObservedVersion(tag, string.Empty);
             return ResultBox.FromValue(false);
         }
         catch (Exception ex)
@@ -334,4 +333,22 @@ public void ClearResults()
     /// </summary>
     [Obsolete("Use ClearResults() instead")]
     public void ClearAppendedEvents() => _appendedEvents.Clear();
+
+    private void TrackObservedVersion(ITag tag, string lastSortableUniqueId)
+    {
+        if (_accessedTagStates.ContainsKey(tag))
+        {
+            return;
+        }
+
+        var tagContent = tag.GetTag().Substring(tag.GetTagGroup().Length + 1);
+        _accessedTagStates[tag] = new TagState(
+            new EmptyTagStatePayload(),
+            0,
+            lastSortableUniqueId,
+            tag.GetTagGroup(),
+            tagContent,
+            string.Empty,
+            string.Empty);
+    }
 }

dcb/src/Sekiban.Dcb.Core/Commands/SerializedCommitAcceptor.cs

@@ -75,6 +75,10 @@ private Task<ResultBox<SerializedCommitResult>> BindLegacyThenExecuteAsync(
         {
             return Malformed(SerializedCommitShapeError.LegacyPayloadInvalid);
         }
+        if (legacy.ConsistencyTags?.Any(entry => entry.LastSortableUniqueId is null) == true)
+        {
+            return Malformed(SerializedCommitShapeError.LegacyPayloadInvalid);
+        }
 
         // Lift losslessly to V1 (per-event tags preserved) before execution — the legacy path is not a shortcut.
         var envelope = LegacyUnversionedSerializedCommitAdapter.ToVersionedV1(legacy);
@@ -100,6 +104,10 @@ private Task<ResultBox<SerializedCommitResult>> BindVersionedThenExecuteAsync(
         {
             return Malformed(SerializedCommitShapeError.VersionedPayloadInvalid);
         }
+        if (envelope.ConsistencyTags?.Any(entry => entry.LastSortableUniqueId is null) == true)
+        {
+            return Malformed(SerializedCommitShapeError.VersionedPayloadInvalid);
+        }
 
         return ExecuteAsync(envelope, cancellationToken);
     }

dcb/src/Sekiban.Dcb.Orleans.Core/Grains/ITagConsistentGrain.cs

@@ -21,7 +21,7 @@ public interface ITagConsistentGrain : IGrainWithStringKey
     /// <summary>
     ///     Make a reservation for a tag write
     /// </summary>
-    Task<ResultBox<TagWriteReservation>> MakeReservationAsync(string lastSortableUniqueId);
+    Task<ResultBox<TagWriteReservation>> MakeReservationAsync(string? lastSortableUniqueId);
 
     /// <summary>
     ///     Confirm a reservation

dcb/src/Sekiban.Dcb.Orleans.Core/Grains/TagConsistentGrain.cs

@@ -47,7 +47,7 @@ public Task<ResultBox<string>> GetLatestSortableUniqueIdAsync()
         return _actor.GetLatestSortableUniqueIdAsync();
     }
 
-    public Task<ResultBox<TagWriteReservation>> MakeReservationAsync(string lastSortableUniqueId)
+    public Task<ResultBox<TagWriteReservation>> MakeReservationAsync(string? lastSortableUniqueId)
     {
         if (_actor == null)
         {

dcb/src/Sekiban.Dcb.Orleans.Core/OrleansActorObjectAccessor.cs

@@ -116,7 +116,7 @@ private class TagConsistentGrainWrapper : ITagConsistentActorCommon
 
         public Task<ResultBox<string>> GetLatestSortableUniqueIdAsync() => _grain.GetLatestSortableUniqueIdAsync();
 
-        public Task<ResultBox<TagWriteReservation>> MakeReservationAsync(string lastSortableUniqueId) =>
+        public Task<ResultBox<TagWriteReservation>> MakeReservationAsync(string? lastSortableUniqueId) =>
             _grain.MakeReservationAsync(lastSortableUniqueId);
 
         public Task<bool> ConfirmReservationAsync(TagWriteReservation reservation) =>