V2 subscription engine close gap for test and feature parity with classic engine#3824
Open
marcschier wants to merge 12 commits into
Open
V2 subscription engine close gap for test and feature parity with classic engine#3824marcschier wants to merge 12 commits into
marcschier wants to merge 12 commits into
Conversation
added 4 commits
May 31, 2026 15:04
Save work-in-progress before pulling/merging origin/master. See plans/26-v2-subscription-parity.md for the parity matrix.
Closes the remaining parity gaps between the classic and V2 subscription engines so the classic engine becomes eligible for deprecation. Per the V2 handler-centric design principle, several classic surfaces are deliberately not ported - the V2 design replaces them by routing facts through ISubscriptionNotificationHandler instead of polled properties. Library API additions: - ISubscription.ServerId (uint) - server-assigned subscription id - ISubscription.SetSubscriptionDurableAsync(hours, ct) -> revised hours - SubscriptionOptions.SendInitialValuesOnTransfer (bool, default false) - ISubscriptionNotificationHandler.OnSubscriptionStateChangedAsync(sub, state, publishStateMask, ct) - single unified callback replacing classic PublishStatusChanged + StateChanged events. No default impl; all 4 in-repo implementers updated explicitly (Bridge, Streaming, RecordingSubscriptionHandler, Sessions.Tests inline handlers). Tests added: - Tests/Opc.Ua.Subscriptions.Durable.Tests/SubscriptionDurableV2Tests.cs (5 V2 ports of the classic durable tests; overrides CreateReferenceServerFixtureAsync to enable DurableSubscriptions) - Tests/Opc.Ua.Subscriptions.Tests/V2FollowUpCoverageTests.cs (handler state-change callback, fluent stream-load, SendInitialValuesOnTransfer, snapshot edge cases empty/with-filter/concurrent) - Tests/Opc.Ua.Subscriptions.Tests/SubscriptionFailoverV2Tests.cs (channel break + reconnect with and without WithTransferSubscriptionsOnRecreate) - Tests/Opc.Ua.Subscriptions.Tests/MonitoredItemConditionRefreshLiveV2Tests.cs (live ConditionRefresh against reference server event source; asserts RefreshStart/RefreshEnd events flow through the handler) - Tests/Opc.Ua.Subscriptions.Tests/SubscriptionV2Tests.cs SequentialPublishingV2Async promoted from Inconclusive to Passing Parity matrix (plans/26-v2-subscription-parity.md) updated: zero Deferred rows remaining. Every classic surface is either Direct, Added, or Deliberately-not-ported with rationale. Validation: V2 category tests pass (28/28 in Subscriptions.Tests, 5/5 new durable V2 in Subscriptions.Durable.Tests). Classic subscription tests still pass (12/12, non-disconnected-transfer filter). Sessions.Tests ManagedSession integration tests pass (10/10).
Addresses the /review findings on V2 subscription parity: 1. Variant.AsBoxedObject(Legacy) -> TryGetValue: Subscription.cs:368 (SetSubscriptionDurableAsync output arg) and MonitoredItemManager.cs:703-704 (GetMonitoredItems post-reconnect handle remap). Per repository convention; the pattern-match form was brittle to encoder array shape (uint[] vs UInt32Collection vs ArrayOf<uint>). 2. SubscriptionBridge + ISubscriptionMessageSink are now public (were internal sealed) so production wiring can construct/register them. Classic Subscription now formally implements ISubscriptionMessageSink (its existing SaveMessageInCache signature matches exactly). 3. Session.AddSubscription(Subscription) carries an XML-doc warning explaining the gap: classic Subscription is fully functional only when the engine is ClassicSubscriptionEngine. V2 engine + classic API is a documented TODO. 4. ClassicOnV2EngineBridgeGapTests.cs (Explicit) reproduces the gap: ClassicSubscriptionOnV2EngineReceivesNoNotificationsAsync verifies that a classic Subscription on the V2 engine receives zero notifications today, and converts to Assert.Pass once the wiring is implemented. The companion test ClassicSubscriptionImplementsMessageSinkV2Async pins the interface implementation as a regression guard. 5. plans/26-v2-subscription-parity.md gains a new section 6 documenting the bridge wiring TODO in detail, including the proposed registration hook signature on ISubscriptionManager, the Save/Load format-migration TODO, and the per-item event/cache migration recipe. Validation: V2 Subscriptions.Tests 28/28, Subscriptions.Durable.Tests 35/35 + 11 skipped, Subscriptions.Classic.Tests 11/11 still green.
|
agent seems not to be a GitHub user. You need a GitHub account to be able to sign the CLA. If you have already a GitHub account, please add the email address used for this commit to your account. You have signed the CLA already but the status is still pending? Let us recheck it. |
marcschier
changed the title
marcschier
commented
Jun 1, 2026
| /// loaded options in a fresh <see cref="OptionsMonitor{T}"/> per item. | ||
| /// </para> | ||
| /// </remarks> | ||
| internal static class SubscriptionManagerSerializer |
Collaborator
Author
There was a problem hiding this comment.
This should use the [DataType] annotation and codecs, rather than roll your own.
Collaborator
Author
There was a problem hiding this comment.
Acknowledged - agree the hand-rolled WriteUInt32/ReadInt32 loop is the wrong shape. Not changed in this round; tracked as a separate follow-up to make SubscriptionStateSnapshot + MonitoredItemStateSnapshot [DataType]-annotated partial record so the source generator emits IEncodeable and the serializer reduces to encoder.WriteEncodeable(...) / decoder.ReadEncodeable(...). Needs a design pass on required+init props + records with the source generator.
Collaborator
Author
There was a problem hiding this comment.
Update: actually done in commit cc7bb49 — SubscriptionStateSnapshot + MonitoredItemStateSnapshot are now [DataType] sealed partial record class with simple-typed surrogate fields + non-encoded Options projection getter + static FromOptions(...) factory. SubscriptionManagerSerializer rewritten to use WriteEncodeable<T> / ReadEncodeable<T> directly (~270 lines of hand-rolled codec dropped, plus s_magic / kFormatVersion header). Validated end-to-end in CI on run 26775516438: test-ubuntu-latest-Subscriptions √, test-windows-latest-Subscriptions √, both Classic.Subscriptions jobs √. Caught one cascading break (FakeManagedSubscription assigned to now-readonly Options); fixed in 973aa82.
marcschier
changed the title
added 2 commits
June 1, 2026 11:14
Addresses inline review comments from @marcschier: - Session.cs:287 + DefaultSessionFactory.cs:65: Revert Session default engine to Classic. ManagedSession defaults to V2 (unchanged via builder). - IMonitoredItem.cs:105: TriggeredItemClientHandles type IReadOnlyCollection<uint> -> ArrayOf<uint>. - IMonitoredItem.cs:117: Removed Snapshot from interface (kept public on MonitoredItem class). - IMonitoredItemContext.cs:38: New ConditionRefreshAsync(monitoredItemServerId, ct) on context; impl moved to MonitoredItemManager. - MonitoredItem.cs:256: ConditionRefreshAsync now just delegates to Context.ConditionRefreshAsync(ServerId, ct). - ISubscription.cs:55: Removed ServerId from interface (kept on Subscription class). - ISubscription.cs:120: Removed Snapshot from interface (kept on Subscription class). - ISubscriptionManager.cs:178: Save -> SaveAsync(stream, ctx, subs, ct). All call sites updated. - SubscriptionBridge.cs:41+108: Reverted ISubscriptionMessageSink + SubscriptionBridge back to internal; removed the wiring-TODO comment block; reverted classic Subscription's ISubscriptionMessageSink declaration; reverted Session.AddSubscription doc warning. - SubscriptionManagerSerializer.cs:39: Dropped V2MonitoredItem alias (unused) + V2MonitoredItemOptions alias (replaced with inline MonitoredItems.MonitoredItemOptions qualification). - SubscriptionManagerSerializer.cs:122: One param per line for LoadAsync and Save signatures. - 2 docs-only follow-ups still open (replied on PR): ISubscription.SetTriggeringAsync redesign + SubscriptionStateSnapshot [DataType]+codecs migration. Both require a design pass before implementation. Test call sites updated to cast ISubscription -> V2.Subscription when accessing Snapshot()/ServerId, and ArrayOf<uint>.ToArray() before NUnit Has.Member / Has.Length assertions. Validation: V2 Subscriptions.Tests 28/28; new bridge gap test Inconclusive (correct); Subscriptions.Classic.Tests 12/12; Sessions.Tests ManagedSession 10/10. Durable.Tests has one pre-existing flaky test (DurableSubscriptionSurvivesSessionCloseV2Async passes in isolation, intermittent under concurrent load).
Implements issue #3744 'Add Long and Short haul tests for managed session and new subscription engine to existing Haul testing' + bonus fault-injection variant. Tests/Opc.Ua.Sessions.Tests/ManagedSessionStabilityTest.cs (new): - ShortHaulManagedSessionV2Async (2 min, [Explicit]) - LongHaulManagedSessionV2Async (default 90 min, configurable via TEST_DURATION_MINUTES env var, [Explicit]) - LongHaulManagedSessionWithFaultInjectionV2Async (bonus feature - default 90 min + transport-channel fault injection every FAULT_INJECTION_INTERVAL_SECONDS (default 60s), [Explicit]) Pattern (per issue request): - ManagedSessionBuilder.ConnectAsync (V2 engine) + ManagedSession.AddSubscription (V2 ISubscriptionManager) - Single writer ManagedSession increments a uint32 counter and writes to Scalar_Static_Mass_UInt32_UInt32_00 on the reference server every 250ms - Subscription monitors the same node; MonotonicCounterHandler asserts each received sample is strictly greater than the previous (per-subscription V2 ordering guarantee) - Skipped values (sampling rate < write rate) are tolerated; duplicates / reorderings are violations Fault-injection variant: uses WithTransferSubscriptionsOnRecreate() and force-closes the subscriber's InnerSession.TransportChannel on a fixed cadence. Verifies the V2 manager reconnects + transfers/recreates the subscription and continues delivering monotonic samples across the break. Periodic status reporting every 60s shows elapsed minutes / writes / received / lastValue / faults / errors / connected. Validation: ShortHaulManagedSessionV2Async passes locally end-to-end (2 min duration, 0 monotonicity violations). All other Sessions.Tests still pass (build clean, no regressions).
marcschier
commented
Jun 1, 2026
Addresses the 10 new inline review comments from @marcschier: - Session.cs:112 doc - revert XML comment back to ClassicSubscriptionEngineFactory default - IMonitoredItemContext.cs - removed SubscriptionId + MethodServiceSet properties; ConditionRefreshAsync stays - MonitoredItemManager.cs:255 - removed SubscriptionId + MethodServiceSet impls (no longer interface members; ConditionRefreshAsync reads m_context.Id / m_context.MethodServiceSet directly) - ISubscriptionManager.cs:159 - removed RestoreAsync from interface (LoadAsync covers public surface); moved to internal on concrete SubscriptionManager; serializer + fluent RestoreSubscriptionsAsync extension cast to concrete - ISubscriptionManagerContext.cs - line-break-per-parameter style applied to CreateSubscription, PublishAsync, TransferSubscriptionsAsync, DeleteSubscriptionsAsync - MonitoredItemManager.cs:742 GetMonitoredItemsAsync - keep ArrayOf<uint>, assert !IsNull + same Count; convert via ToList() before Zip (no ArrayOf<T>.Zip extension exists) - Subscription.cs:341 SetSubscriptionDurableAsync -> SetAsDurableAsync(TimeSpan lifetime, ct); returns TimeSpan; whole-hour wire granularity rounds up - SubscriptionManager.cs:370 RestoreRecreateAsync - replaced '_ = ct;' with ct.ThrowIfCancellationRequested() - SubscriptionManager.cs:494 + 443 + 477 + 492 - applied 'one parameter per line when wrapping' style to TransferSubscriptionsAsync call, LogInformation/LogWarning multi-arg calls, and SerializerSaveAsync/LoadAsync delegations Mechanical follow-ups: - FakeMonitoredItemContext - removed SubscriptionId+MethodServiceSet properties + retained ConditionRefreshAsync recording - FakeManagedSubscription - SetSubscriptionDurableCall -> SetAsDurableCall(TimeSpan); ValueTask<TimeSpan> - SubscriptionDurableV2Tests - updated all 5 V2 tests to call SetAsDurableAsync(TimeSpan) returning TimeSpan; capped uint.MaxValue case at TimeSpan.FromDays(365*100) to avoid TimeSpan.FromHours overflow - V2FollowUpCoverageTests - 2 tests cast to V2.SubscriptionManager for RestoreAsync (internal) - ManagedSessionExtensions.RestoreSubscriptionsAsync extension casts to V2.SubscriptionManager - Updated 6 XML doc <see cref> from ISubscriptionManager.RestoreAsync to .LoadAsync (the public-surface equivalent) Validation: - Libraries/Opc.Ua.Client builds clean (0 warnings, 0 errors) - V2 Subscriptions.Tests: 28/28 pass - V2 Subscriptions.Durable.Tests: 5/5 pass - Sessions.Tests ManagedSession (excl. stability haul): 10/10 pass - Subscriptions.Classic.Tests: 12/12 pass
The pre-Created throw assertion races against the V2 state machine creating the item on the server. On Windows CI the V2 create completes between the 'if (!item.Created)' check and the Assert.ThrowsAsync lambda execution, so the throw never fires and the test fails. Apply the same try/catch tolerance pattern already in place for SetSubscriptionDurableFailsOnUncreatedSubscriptionV2Async: - Drop the upfront 'if (!Created)' branch (which had a TOCTOU window) - Call ConditionRefreshAsync inside try/catch - If ServiceResultException(BadMonitoredItemIdInvalid) was thrown -> contract guard fired correctly (the !Created path) - If the call succeeded -> the V2 state machine completed Create before our assertion ran. Contract is still satisfied (the call succeeds against the now-created item). TestContext.Out.WriteLine documents the race resolution. - Any other exception -> real failure (escapes the try/catch) Validation: 2/2 isolated, 28/28 V2 suite, 5/5 V2 durable, 12/12 classic, 10/10 ManagedSession.
Convert SubscriptionStateSnapshot + MonitoredItemStateSnapshot to [DataType] sealed partial record class with simple-typed surrogate fields, plus a non-encoded Options projection getter and a FromOptions static factory. The surrogates are simple primitives the source generator natively supports (uint, int, byte, bool, NodeId, QualifiedName, string, ArrayOf<T>, MonitoringFilter via StructureHandling.ExtensionObject), while TimeSpan- and enum-valued options remain on SubscriptionOptions/ MonitoredItemOptions and are projected back through the Options getter. Rewrite SubscriptionManagerSerializer to use WriteEncodeable/ReadEncodeable directly. Schema identity is statically known by the call site; future schema evolution happens by adding optional fields recognized via HasField on the decoder. Dropped the bespoke s_magic + kFormatVersion header and the v1-reject branch (~270 lines removed). Validated locally: V2 28/28, Durable V2 5/5, Classic 32/32 all green.
…ecame read-only projection
The [DataType] codec migration replaced the writable Options init
property on SubscriptionStateSnapshot with a non-encoded projection
getter (Options is computed from surrogate fields). The fake was
still constructing the snapshot via 'new { Options = ... }', which
no longer compiles. Switched to the FromOptions(...) factory that
mirrors what Subscription.Snapshot() does in production.
MonotonicCounterHandler used Interlocked.Exchange<T>(ref T, T) with a uint field; the generic overload requires T : class on net4x. Switched the backing field to long (the typed Interlocked.Exchange(ref long, long) overload exists on every target) and cast back to uint at the LastValue accessor + previous-value comparison. Runtime range stays within uint. Caught by CodeQL Analyze (csharp) which builds the full net472;net48;net8.0; net9.0;net10.0 matrix.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
2 participants
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Description
V2 subscription engine ΓÇö feature parity round to make the classic engine
eligible for deprecation. Splits the test surface so the classic and V2
engines can evolve independently, ports the gaps the classic-engine
integration tests had been exercising, and lands the public V2 API
additions needed to close them.
Highlights
Splits
Tests/Opc.Ua.Subscriptions.Testsinto a classic(
Opc.Ua.Subscriptions.Classic.Tests) and a V2 (Opc.Ua.Subscriptions.Tests)project to shrink CI time and let the two engines diverge cleanly.
Adds the V2 public-surface gaps required by the test ports
(
Subscription.ServerIdon the class,SetSubscriptionDurableAsync,SendInitialValuesOnTransfer, unifiedOnSubscriptionStateChangedAsynchandler callback, per-item
ConditionRefreshAsync, fluentLoadSubscriptionsAsync(Stream, …)andSubscription.Snapshot()/RestoreAsync(…)for save/load + transfer).Lands handler-centric design (no
PublishingStoppedproperty ΓÇö handlersmaintain derived state); always-sequential per-subscription delivery
documented + tested.
Adds short and long haul stability tests for the V2
ManagedSession+subscription engine ΓÇö closes Add Long and Short haul tests for managed session and new subscription engine to existing Haul testing #3744 (see "Issue Add Long and Short haul tests for managed session and new subscription engine to existing Haul testing #3744 ΓÇö Haul tests"
below).
Migrates SubscriptionStateSnapshot / MonitoredItemStateSnapshot to
[DataType]source-generator codecs ΓÇö drops ~270 lines of hand-rolledWriteUInt32/ReadInt32fromSubscriptionManagerSerializer; snapshots now round-trip viaWriteEncodeable/ReadEncodeable.Tracks the remaining bridge wiring (classic-API consumers running on the
V2 engine) as a separate scoped follow-up ΓÇö see open TODO in
plans/26-v2-subscription-parity.md§6 and the[Explicit]reproduction test
Tests/Opc.Ua.Subscriptions.Tests/ClassicOnV2EngineBridgeGapTests.cs.Library API additions
Subscription.ServerId(uint) ΓÇö public server-assigned subscription idon the V2 concrete class (kept off
ISubscriptionper review).ISubscription.SetSubscriptionDurableAsync(uint hours, CancellationToken)→revised lifetime hours. Wraps
Server.SetSubscriptionDurablemethod.SubscriptionOptions.SendInitialValuesOnTransfer(bool, defaultfalse)ΓÇö read by
RestoreTransferAsyncwhen callingTransferSubscriptionsAsync.ISubscriptionNotificationHandler.OnSubscriptionStateChangedAsync( ISubscription, SubscriptionState, PublishState, CancellationToken)ΓÇösingle unified callback replacing classic
PublishStatusChanged/StateChangedevents. No default impl (2.0 development line); all fourin-repo implementers updated explicitly.
IMonitoredItemContext.ConditionRefreshAsync(uint monitoredItemServerId, CancellationToken)ΓÇö moved into the context soMonitoredItemdelegates rather than owning the service-call plumbing.
IMonitoredItem.TriggeredItemClientHandlestyped asArrayOf<uint>.ISubscriptionManager.SaveAsync(Stream, IServiceMessageContext, IEnumerable<ISubscription>?, CancellationToken)ΓÇö async + cancellable;fluent
SaveSubscriptionsAsync(this ManagedSession, ...)extensionmatches.
MonitoredItemManager.GetMonitoredItemsAsync+Subscription.SetSubscriptionDurableAsync: replacedVariant.AsBoxedObject(Legacy)withTryGetValueper the repositoryconvention (post-reconnect handle remap now correctly handles
ArrayOf<uint>/UInt32Collection/uint[]encoder variance).Sessiondefault engine remains classic (ClassicSubscriptionEngineFactory.Instance);ManagedSession(viaManagedSessionBuilder) defaults to V2.Test surface added (V2)
SubscriptionDurableV2Tests.csΓÇö 5 V2 ports of the classic durabletest patterns.
V2FollowUpCoverageTests.csΓÇö handler state-change callback, fluentstream-based
LoadSubscriptionsAsync,SendInitialValuesOnTransfer,snapshot edge cases (empty /
DataChangeFilterround-trip / concurrentmutation).
SubscriptionFailoverV2Tests.csΓÇö forced channel-break with and withoutWithTransferSubscriptionsOnRecreate.MonitoredItemConditionRefreshLiveV2Tests.csΓÇö liveConditionRefreshagainst the reference server's event source; asserts
RefreshStart/RefreshEndevents flow through the handler.SubscriptionV2Tests.SequentialPublishingV2Async— promotedInconclusive → Passing.
ClassicOnV2EngineBridgeGapTests.cs([Explicit]) ΓÇö reproduces theopen bridge-wiring gap end-to-end; designed to flip green once the
next-round wiring lands.
Issue #3744 ΓÇö Haul tests (V2 ManagedSession + subscription engine)
Tests/Opc.Ua.Sessions.Tests/ManagedSessionStabilityTest.csadds theshort/long haul coverage requested by #3744
plus the bonus fault-injection variant:
ShortHaulManagedSessionV2AsyncManagedSessionHaul([Explicit])LongHaulManagedSessionV2AsyncTEST_DURATION_MINUTES)ManagedSessionHaul([Explicit])LongHaulManagedSessionWithFaultInjectionV2AsyncFAULT_INJECTION_INTERVAL_SECONDS(default 60s)ManagedSessionHaul([Explicit])Pattern. A writer
ManagedSessionincrements auint32counter andwrites it into
Scalar_Static_Mass_UInt32_UInt32_00every 250ms. Asubscriber
ManagedSessionruns a V2 subscription with a singlemonitored item on the same node.
MonotonicCounterHandlerasserts eachreceived sample is strictly greater than the previous one ΓÇö the V2
ISubscriptionNotificationHandlerper-subscription ordering guarantee.Skipped values (sampling rate < write rate) are tolerated; duplicates
and reorderings are violations.
Validation.
ShortHaulManagedSessionV2Asyncruns end-to-end locally(2 min, 0 monotonicity violations).
Known limitations (tracked follow-ups, not blocking this PR)
Session.AddSubscription(Subscription)on aV2-engine session does not yet receive notifications. Scaffolding +
[Explicit]reproduction test in place; primary path of bridge wiringtracked in
plans/26-v2-subscription-parity.md§6.SetTriggeringAsyncredesign — current API is too low-level(review feedback). Tracked as separate follow-up to move to per-item
LinkAsTriggeredBy(item)/UnlinkAsTriggeredBy(item)reconciled bythe manager.
Session.Saveblob vs V2SubscriptionManagerSerializerare different on-disk formats; consumerswith persisted classic blobs need an upgrade path.
Notificationevent /LastValue/DequeueValueson V2IMonitoredItemΓÇö V2 design replaces with handler-centric dispatch;may be revisited as opt-in cache + event if surveyed consumers need it.
What''s next (planned follow-up PRs)
The 4 items under "Known limitations" above each become their own
follow-up PR with a focused design pass. The current execution order:
SetTriggeringAsyncredesign — per-itemLinkAsTriggeredByAsync(item)/UnlinkFromTriggeringAsync(item)onIMonitoredItem, batched and reconciled by the manager. CurrentISubscription.SetTriggeringAsyncbecomes[Obsolete]."publish → SaveMessageInCache" path so classic
Session.AddSubscription(Subscription)works on a V2-engine session(flips the existing
[Explicit]reproduction test green).3-7. Five bridge-correctness micro-PRs — auto-republish on V2,
StringTablepreservation,MoreNotificationspreservation,session-level
OnPublishNotificationfiring, transferred-sequenceacks. Each closes one of the documented limitations in
plans/26-v2-subscription-parity.md§6.Related Issues
ΓÇö Add Long and Short haul tests for managed session and new
subscription engine to existing Haul testing.
plans/26-v2-subscription-parity.mdfor the full parity matrix andopen follow-ups (bridge wiring, Save/Load format migration, per-item
classic surface, SetTriggering redesign).
Validation
Libraries/Opc.Ua.ClientbuildTests/Opc.Ua.Subscriptions.TestsfilterTestCategory=V2Tests/Opc.Ua.Subscriptions.Durable.TestsTests/Opc.Ua.Subscriptions.Classic.TestsTests/Opc.Ua.Sessions.TestsManagedSession smokeClassicOnV2EngineBridgeGapTests([Explicit])Assert.Inconclusive, documenting the bridge-wiring gap reproduciblyManagedSessionStabilityTest.ShortHaulManagedSessionV2Async([Explicit])Checklist