Add interoperability evidence registry

Author: ammarheidari

README.md

@@ -37,6 +37,7 @@ The first production milestone is M3UA over a transport abstraction. SCCP, TCAP,
 | Interoperability tooling | Phase 6 foundation-ready: trace frames, Wireshark-friendly hex dumps, conformance vectors, built-in M3UA/MAP vectors, simulator scripts, MAP SMS flow builders, local TCP samples, sample catalog, CI profile, and readiness report; production gate is external interoperability lab evidence |
 | Commercial readiness | Phase 7 started: internal release readiness is available; commercial production readiness requires native SCTP verification, external interoperability evidence, and release governance |
 | Native SCTP support | Phase 7 matrix added: Linux requires lab verification; Windows and macOS are contract-only until a production provider is verified |
+| External interoperability evidence | Phase 7 registry added for peer-stack lab results and packet trace references; current evidence inventory is empty until real lab artifacts are captured |
 
 ## Requirements
 

docs/INTEROPERABILITY.md

@@ -105,3 +105,5 @@ bool productionReady = report.IsProductionReady;
 The foundation gate is complete when trace formatting, conformance vectors, built-in vectors, simulator scripts, MAP SMS flows, transport samples, sample catalog, and CI profile are all present.
 
 Production readiness remains false until external interoperability lab evidence is captured against real peer stacks and packet traces.
+
+Phase 7 adds `SigtranInteropEvidenceRegistry` so those lab artifacts can be tracked as stable release evidence instead of free-form notes.

docs/PHASE7_COMMERCIALIZATION.md

@@ -27,3 +27,19 @@ Commercial readiness remains blocked until native SCTP verification, external in
 | macOS | Contract only |
 
 Linux is the target for native SCTP lab verification. Windows and macOS remain supported through transport contracts and development adapters until a production provider is selected and verified.
+
+## External Interoperability Evidence
+
+`SigtranInteropEvidenceRegistry` records evidence from real peer stacks and captured traces.
+
+```csharp
+SigtranInteropEvidenceRegistry registry = new();
+registry.Add(new SigtranInteropEvidenceItem(
+    "lab/linux/m3ua-asp",
+    "openss7",
+    "M3UA ASP to SG",
+    "traces/m3ua-asp.pcapng",
+    SigtranInteropEvidenceResult.Passed));
+```
+
+The current registry is intentionally empty until real lab artifacts are added. Commercial readiness requires at least one passing external evidence item, and later release policies should require multiple peer stacks and scenarios.

src/sigtran.net.Tests/Program.cs

@@ -22,6 +22,7 @@
 Run("SIGTRAN phase 6 status summarizes completed tooling", SigtranPhase6StatusSummarizesCompletedTooling);
 Run("SIGTRAN commercial readiness reports release gates", SigtranCommercialReadinessReportsReleaseGates);
 Run("SIGTRAN native SCTP support matrix reports verification status", SigtranNativeSctpSupportMatrixReportsVerificationStatus);
+Run("SIGTRAN interop evidence registry tracks lab results", SigtranInteropEvidenceRegistryTracksLabResults);
 Run("TCAP BER element encodes short and long lengths", TcapBerElementEncodesShortAndLongLengths);
 Run("TCAP transaction identifiers use BER context tags", TcapTransactionIdentifiersUseBerContextTags);
 Run("TCAP BER Invoke component round-trips", TcapBerInvokeComponentRoundTrips);
@@ -293,6 +294,17 @@ static void SigtranNativeSctpSupportMatrixReportsVerificationStatus()
     Assert(!SigtranNativeSctpSupport.IsProductionVerified(), "native SCTP should not be production verified yet");
 }
 
+static void SigtranInteropEvidenceRegistryTracksLabResults()
+{
+    SigtranInteropEvidenceRegistry registry = new();
+    registry.Add(new SigtranInteropEvidenceItem("lab/linux/m3ua-asp", "openss7", "M3UA ASP to SG", "traces/m3ua-asp.pcapng", SigtranInteropEvidenceResult.Passed));
+
+    AssertEqual(1, registry.Snapshot().Count, "interop evidence count");
+    Assert(registry.HasPassingEvidence(), "interop evidence should pass with one passing item");
+    AssertThrows<InvalidOperationException>(() => registry.Add(registry.Snapshot()[0]));
+    Assert(!SigtranInteropEvidence.CreateCurrentRegistry().HasPassingEvidence(), "current interop evidence should be empty until real lab artifacts are added");
+}
+
 static void TcapBerElementEncodesShortAndLongLengths()
 {
     Span<byte> shortBuffer = stackalloc byte[8];

src/sigtran.net/Core/Utilities/SigtranCommercialReadiness.cs

@@ -74,7 +74,7 @@ public static SigtranCommercialReadinessReport GetReport()
             hasInteroperabilityTooling: SigtranInteroperabilityReadiness.GetReport().FoundationReady,
             hasCiVerification: SigtranCiVerification.CreateDefaultProfile().Steps.Count > 0,
             hasNativeSctpVerification: SigtranNativeSctpSupport.IsProductionVerified(),
-            hasExternalInteroperabilityEvidence: false,
+            hasExternalInteroperabilityEvidence: SigtranInteropEvidence.CreateCurrentRegistry().HasPassingEvidence(),
             hasReleaseGovernance: false);
     }
 }

src/sigtran.net/Core/Utilities/SigtranInteropEvidence.cs

@@ -0,0 +1,105 @@
+namespace sigtran.net.Core.Utilities;
+
+/// <summary>
+/// Identifies the result of an external interoperability evidence item.
+/// </summary>
+public enum SigtranInteropEvidenceResult
+{
+    /// <summary>The evidence item passed.</summary>
+    Passed,
+
+    /// <summary>The evidence item failed.</summary>
+    Failed,
+
+    /// <summary>The evidence item is informational only.</summary>
+    Informational
+}
+
+/// <summary>
+/// Describes one external interoperability evidence item.
+/// </summary>
+public sealed class SigtranInteropEvidenceItem
+{
+    /// <summary>Creates an interoperability evidence item.</summary>
+    /// <param name="id">The stable evidence id.</param>
+    /// <param name="peerStack">The peer stack or product name.</param>
+    /// <param name="scenario">The tested scenario.</param>
+    /// <param name="traceReference">The trace or artifact reference.</param>
+    /// <param name="result">The evidence result.</param>
+    public SigtranInteropEvidenceItem(
+        string id,
+        string peerStack,
+        string scenario,
+        string traceReference,
+        SigtranInteropEvidenceResult result)
+    {
+        Id = string.IsNullOrWhiteSpace(id) ? throw new ArgumentException("Evidence id is required.", nameof(id)) : id;
+        PeerStack = string.IsNullOrWhiteSpace(peerStack) ? throw new ArgumentException("Peer stack is required.", nameof(peerStack)) : peerStack;
+        Scenario = string.IsNullOrWhiteSpace(scenario) ? throw new ArgumentException("Scenario is required.", nameof(scenario)) : scenario;
+        TraceReference = string.IsNullOrWhiteSpace(traceReference) ? throw new ArgumentException("Trace reference is required.", nameof(traceReference)) : traceReference;
+        Result = result;
+    }
+
+    /// <summary>The stable evidence id.</summary>
+    public string Id { get; }
+
+    /// <summary>The peer stack or product name.</summary>
+    public string PeerStack { get; }
+
+    /// <summary>The tested scenario.</summary>
+    public string Scenario { get; }
+
+    /// <summary>The trace or artifact reference.</summary>
+    public string TraceReference { get; }
+
+    /// <summary>The evidence result.</summary>
+    public SigtranInteropEvidenceResult Result { get; }
+}
+
+/// <summary>
+/// Stores external interoperability evidence in deterministic order.
+/// </summary>
+public sealed class SigtranInteropEvidenceRegistry
+{
+    private readonly List<SigtranInteropEvidenceItem> _items = [];
+
+    /// <summary>Adds an evidence item.</summary>
+    /// <param name="item">The evidence item.</param>
+    public void Add(SigtranInteropEvidenceItem item)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        if (_items.Any(existing => string.Equals(existing.Id, item.Id, StringComparison.OrdinalIgnoreCase)))
+        {
+            throw new InvalidOperationException($"Interop evidence '{item.Id}' already exists.");
+        }
+
+        _items.Add(item);
+    }
+
+    /// <summary>Returns a deterministic evidence snapshot.</summary>
+    /// <returns>The evidence snapshot.</returns>
+    public IReadOnlyList<SigtranInteropEvidenceItem> Snapshot()
+    {
+        return _items.ToArray();
+    }
+
+    /// <summary>Returns whether all evidence items passed and at least one item exists.</summary>
+    /// <returns>True when the registry has passing evidence; otherwise false.</returns>
+    public bool HasPassingEvidence()
+    {
+        return _items.Count > 0 && _items.All(static item => item.Result == SigtranInteropEvidenceResult.Passed);
+    }
+}
+
+/// <summary>
+/// Provides external interoperability evidence inventory helpers.
+/// </summary>
+public static class SigtranInteropEvidence
+{
+    /// <summary>Creates the current external evidence registry.</summary>
+    /// <returns>The current external evidence registry.</returns>
+    public static SigtranInteropEvidenceRegistry CreateCurrentRegistry()
+    {
+        return new SigtranInteropEvidenceRegistry();
+    }
+}