fix(scl): gate export-only counter correction on exact live integer type

MainWindow.xaml.cs

@@ -1700,12 +1700,12 @@ private void SaveTypedModelAsScl(
                     canonical,
                     result);
 
-                if (semanticPatch.Changed)
+                if (semanticPatch.Messages.Count > 0)
                 {
                     AddLog(
-                        "INFO",
+                        semanticPatch.Changed ? "INFO" : "WARN",
                         "SCL Export",
-                        $"{device.Name}: export-only semantic parity applied after canonical serialization and before reload validation • " +
+                        $"{device.Name}: export-only semantic parity {(semanticPatch.Changed ? "applied" : "skipped")} after canonical serialization and before reload validation • " +
                         string.Join(" ", semanticPatch.Messages));
                 }
             }

Services/SclExportSemanticParityPatch.cs

@@ -30,24 +30,50 @@ public static SclExportSemanticParityPatchResult ApplyForLiveModel(
         if (!File.Exists(sclPath))
             throw new FileNotFoundException("Generated SCL file does not exist.", sclPath);
 
-        // This compatibility correction is deliberately keyed to the exact object
-        // proven by the physical comparison. It is not a generic name/value guess.
-        var targetExistsInLiveModel = liveModel.LogicalDevices
+        // The object name narrows the compatibility scope; it is not sufficient
+        // evidence for a CDC/type correction on another relay or firmware.
+        var targetDataObjects = liveModel.LogicalDevices
             .SelectMany(device => device.LogicalNodes)
             .Where(node => string.Equals(node.Name, TargetLogicalNodeName, StringComparison.Ordinal))
             .SelectMany(node => node.DataObjects)
-            .Any(dataObject =>
+            .Where(dataObject =>
                 string.Equals(dataObject.Name, TargetDataObject, StringComparison.Ordinal) &&
                 dataObject.Reference.EndsWith(
                     "/" + TargetLogicalNodeName + "." + TargetDataObject,
-                    StringComparison.Ordinal));
+                    StringComparison.Ordinal))
+            .ToArray();
+
+        if (targetDataObjects.Length == 0)
+        {
+            return new SclExportSemanticParityPatchResult(
+                0, 0, Array.Empty<string>());
+        }
+
+        if (targetDataObjects.Length != 1)
+        {
+            throw new InvalidDataException(
+                $"Ambiguous live {TargetLogicalNodeName}.{TargetDataObject}: {targetDataObjects.Length} matching objects.");
+        }
+
+        var exactIntegerStatus = targetDataObjects[0].Attributes
+            .Where(attribute =>
+                string.Equals(attribute.AttributePath, "stVal", StringComparison.Ordinal) &&
+                string.Equals(attribute.FunctionalConstraint, "ST", StringComparison.Ordinal) &&
+                string.Equals(attribute.TypeDiscoveryStatus, "Exact", StringComparison.Ordinal) &&
+                attribute.TypeConfidence == LiveIedDiscoveryConfidenceLevel.Exact &&
+                string.Equals(attribute.SclBType, "INT32", StringComparison.OrdinalIgnoreCase))
+            .ToArray();
 
-        if (!targetExistsInLiveModel)
+        if (exactIntegerStatus.Length != 1)
         {
+            // Preserve a legitimately Boolean or unproven status object. Never invent
+            // INS/INT32 from the name, old inferred CDC, or an instance Val string.
             return new SclExportSemanticParityPatchResult(
                 0,
                 0,
-                Array.Empty<string>());
+                [
+                    $"{TargetLogicalNodeName}.{TargetDataObject}: export-only correction skipped; exact ST stVal INT32 TypeSpecification evidence is unavailable or ambiguous."
+                ]);
         }
 
         var document = XDocument.Load(sclPath, LoadOptions.PreserveWhitespace);

tests/ARSAS.Tests/SclExportSemanticParityPatchTests.cs

@@ -118,6 +118,45 @@ public void PhysicalReferenceCounter_IsCorrectedOnlyInSavedScl_AndSharedTypeIsNo
         }
     }
 
+    [Theory]
+    [InlineData("BOOLEAN", "Exact", LiveIedDiscoveryConfidenceLevel.Exact)]
+    [InlineData("INT32", "NotRead", LiveIedDiscoveryConfidenceLevel.Low)]
+    [InlineData("INT32", "Exact", LiveIedDiscoveryConfidenceLevel.Low)]
+    [InlineData("INT32U", "Exact", LiveIedDiscoveryConfidenceLevel.Exact)]
+    public void MissingOrContradictoryLiveType_DoesNotInventInsInSavedScl(
+        string sclBType,
+        string discoveryStatus,
+        LiveIedDiscoveryConfidenceLevel confidence)
+    {
+        var root = Path.Combine(
+            Path.GetTempPath(),
+            "arsas-scl-exact-type-gate-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(root);
+        var path = Path.Combine(root, "relay.iid");
+
+        try
+        {
+            const string xml = "<SCL xmlns=\"http://www.iec.ch/61850/2003/SCL\"><DataTypeTemplates /></SCL>";
+            File.WriteAllText(path, xml);
+            var model = PhysicalReferenceModel(sclBType, discoveryStatus, confidence);
+            var result = SclExportSemanticParityPatch.ApplyForLiveModel(model, path);
+
+            Assert.False(result.Changed);
+            Assert.Equal(0, result.PatchedDataObjects);
+            Assert.Contains(result.Messages, message =>
+                message.Contains("exact ST stVal INT32", StringComparison.Ordinal));
+            Assert.Equal(xml, File.ReadAllText(path));
+            Assert.Equal("SPS", Assert.Single(model.LogicalDevices
+                .SelectMany(device => device.LogicalNodes)
+                .SelectMany(node => node.DataObjects)).InferredCdc);
+        }
+        finally
+        {
+            if (Directory.Exists(root))
+                Directory.Delete(root, recursive: true);
+        }
+    }
+
     [Fact]
     public void NonTargetLiveModel_DoesNotRewriteSavedScl()
     {
@@ -179,7 +218,10 @@ public void SaveHook_IsAfterCanonicalSerialization_AndBeforeReloadValidation()
             StringComparison.Ordinal);
     }
 
-    private static LiveIedModelDiscoveryDocument PhysicalReferenceModel()
+    private static LiveIedModelDiscoveryDocument PhysicalReferenceModel(
+        string sclBType = "INT32",
+        string discoveryStatus = "Exact",
+        LiveIedDiscoveryConfidenceLevel confidence = LiveIedDiscoveryConfidenceLevel.Exact)
         => new()
         {
             LogicalDevices =
@@ -202,7 +244,19 @@ private static LiveIedModelDiscoveryDocument PhysicalReferenceModel()
                                 {
                                     Reference = "AA1E1F06R4ADD/MPLS_GGIO1.CBClsCounter",
                                     Name = "CBClsCounter",
-                                    InferredCdc = "SPS"
+                                    InferredCdc = "SPS",
+                                    Attributes =
+                                    [
+                                        new LiveIedDataAttributeModel
+                                        {
+                                            ObjectReference = "AA1E1F06R4ADD/MPLS_GGIO1.CBClsCounter.stVal",
+                                            AttributePath = "stVal",
+                                            FunctionalConstraint = "ST",
+                                            SclBType = sclBType,
+                                            TypeDiscoveryStatus = discoveryStatus,
+                                            TypeConfidence = confidence
+                                        }
+                                    ]
                                 }
                             ]
                         }