Merge R2-11 TagConfig consolidation (arch-review round 2) [PR #434]

Findings 01/C-1, 01/P-1 (single TagConfigIntent.Parse in Commons, 4 copies
delegate, parse-once) + 05 CONV-2/UNDER-1/UNDER-6 (shared strict TagConfigJson
readers, per-driver Inspect() + writable key, FOCAS capability pre-flight,
Modbus probe timeoutMs, deploy-gate Warn|Error). Phase C runtime-strict flip
deferred. T22/T24 deferred. Auto-merged AddressSpaceApplier.cs + DriverHostActor.cs
with R2-04/R2-10; verified OpcUaServer.Tests 286/286 + Runtime.Tests 396/396.
Build clean.

src/Core/ZB.MOM.WW.OtOpcUa.Commons/Types/DeviceConfigIntent.cs

@@ -0,0 +1,47 @@
+using System.Text.Json;
+
+namespace ZB.MOM.WW.OtOpcUa.Commons.Types;
+
+/// <summary>
+///     SINGLE SOURCE OF TRUTH for extracting + normalizing a <c>Device</c>'s connection host from its
+///     schemaless <c>DeviceConfig</c> JSON. Shared by the live-compose seam (<c>AddressSpaceComposer</c>),
+///     the artifact-decode seam (<c>DeploymentArtifact</c>), and the FixedTree-partition path
+///     (<c>DriverHostActor</c>) so an <c>EquipmentNode.DeviceHost</c> and a driver-discovered device-host
+///     folder segment for the same device compare byte-equal. Ported verbatim from the historical
+///     <c>AddressSpaceComposer.TryExtractDeviceHost</c> / <c>NormalizeDeviceHost</c>.
+/// </summary>
+public static class DeviceConfigIntent
+{
+    /// <summary>
+    ///     Extract a <c>Device</c>'s connection host from its schemaless <c>DeviceConfig</c> JSON: the
+    ///     top-level <c>"HostAddress"</c> string (e.g. <c>"10.201.31.5:8193"</c>). Returns
+    ///     <see langword="null"/> when the config is blank, not a JSON object, has no string
+    ///     <c>HostAddress</c>, or the value is blank/whitespace. Never throws. The returned host is
+    ///     deterministically normalized via <see cref="NormalizeHost"/> (trim + lower-case).
+    /// </summary>
+    /// <param name="deviceConfigJson">The device's schemaless <c>DeviceConfig</c> JSON blob.</param>
+    /// <returns>The normalized device host, or <see langword="null"/> when absent/blank/unparseable.</returns>
+    public static string? TryExtractHost(string? deviceConfigJson)
+    {
+        if (string.IsNullOrWhiteSpace(deviceConfigJson)) return null;
+        try
+        {
+            using var doc = JsonDocument.Parse(deviceConfigJson);
+            if (doc.RootElement.ValueKind != JsonValueKind.Object) return null;
+            if (!doc.RootElement.TryGetProperty("HostAddress", out var hostEl)
+                || hostEl.ValueKind != JsonValueKind.String) return null;
+            var raw = hostEl.GetString();
+            if (string.IsNullOrWhiteSpace(raw)) return null;
+            return NormalizeHost(raw);
+        }
+        catch (JsonException) { return null; }
+    }
+
+    /// <summary>
+    ///     The single normalization authority for a device host: trims surrounding whitespace and
+    ///     lower-cases (invariant). Idempotent (an already-normalized value is unchanged).
+    /// </summary>
+    /// <param name="host">The raw host string (non-null; a non-empty <c>HostAddress</c> or folder segment).</param>
+    /// <returns>The normalized host (trimmed + lower-cased).</returns>
+    public static string NormalizeHost(string host) => host.Trim().ToLowerInvariant();
+}

src/Core/ZB.MOM.WW.OtOpcUa.Commons/Types/TagConfigIntent.cs

@@ -0,0 +1,129 @@
+using System.Text.Json;
+
+namespace ZB.MOM.WW.OtOpcUa.Commons.Types;
+
+/// <summary>
+///     The cross-driver platform intents parsed from a Tag's schemaless <c>TagConfig</c> JSON.
+///     SINGLE SOURCE OF TRUTH for the byte-parity contract shared by the live-compose seam
+///     (<c>AddressSpaceComposer</c>), the artifact-decode seam (<c>DeploymentArtifact</c>), the draft
+///     gate (<c>DraftValidator</c>), and the walker (<c>EquipmentNodeWalker</c>). One
+///     <see cref="JsonDocument.Parse(string)"/> per blob. Never throws.
+///     <para>Two deliberate variations are carried on the record so every seam can be served from one
+///     parse:</para>
+///     <list type="bullet">
+///         <item><description><see cref="FullName"/> is the driver-side wire reference: the top-level
+///         <c>FullName</c> string when present, else the RAW blob (an equipment tag's TagConfig JSON
+///         <em>is</em> its wire reference for the six protocol drivers). <c>Parse(null)</c> ⇒
+///         <c>FullName == ""</c>.</description></item>
+///         <item><description><see cref="ExplicitFullName"/> is the <c>FullName</c> property ONLY when
+///         present-and-string, else <see langword="null"/> — the DraftValidator Galaxy-rule semantics
+///         (it wants the explicit reference, not the raw-blob fallback).</description></item>
+///     </list>
+/// </summary>
+/// <param name="FullName">Top-level <c>FullName</c> string, else the raw blob (wire-reference fallback).</param>
+/// <param name="ExplicitFullName">The <c>FullName</c> property when present-and-string, else <see langword="null"/>.</param>
+/// <param name="Alarm">The optional native-alarm intent parsed from the <c>alarm</c> object; <see langword="null"/> ⇒ plain value variable.</param>
+/// <param name="IsHistorized"><c>isHistorized</c> — true only when the value is a bool <c>true</c>.</param>
+/// <param name="HistorianTagname">Non-whitespace <c>historianTagname</c> string override, else <see langword="null"/> (not trimmed).</param>
+/// <param name="IsArray"><c>isArray</c> bool.</param>
+/// <param name="ArrayLength"><c>arrayLength</c> honoured ONLY when <see cref="IsArray"/> and a JSON number fitting <see cref="uint"/>; else <see langword="null"/>.</param>
+public sealed record TagConfigIntent(
+    string FullName,
+    string? ExplicitFullName,
+    TagAlarmIntent? Alarm,
+    bool IsHistorized,
+    string? HistorianTagname,
+    bool IsArray,
+    uint? ArrayLength)
+{
+    /// <summary>
+    ///     Parse a Tag's schemaless <c>TagConfig</c> JSON into the cross-driver platform intents.
+    ///     Never throws: malformed JSON / non-object root / blank / null ⇒ all intents default with
+    ///     <see cref="FullName"/> = the raw blob (or "" for null). Semantics are ported verbatim from the
+    ///     historical <c>AddressSpaceComposer.Extract*</c> statics (the canonical copy).
+    /// </summary>
+    /// <param name="tagConfig">The tag's raw <c>TagConfig</c> JSON (nullable/blank tolerated).</param>
+    /// <returns>The parsed intents; never <see langword="null"/>.</returns>
+    public static TagConfigIntent Parse(string? tagConfig)
+    {
+        if (string.IsNullOrWhiteSpace(tagConfig))
+            return new TagConfigIntent(tagConfig ?? string.Empty, null, null, false, null, false, null);
+
+        try
+        {
+            using var doc = JsonDocument.Parse(tagConfig);
+            var root = doc.RootElement;
+            if (root.ValueKind != JsonValueKind.Object)
+                return new TagConfigIntent(tagConfig, null, null, false, null, false, null);
+
+            var explicitFullName =
+                root.TryGetProperty("FullName", out var fn) && fn.ValueKind == JsonValueKind.String
+                    ? fn.GetString()
+                    : null;
+            var fullName = explicitFullName ?? tagConfig;
+
+            var (isHistorized, historianTagname) = ParseHistorize(root);
+            var (isArray, arrayLength) = ParseArray(root);
+
+            return new TagConfigIntent(
+                fullName, explicitFullName, ParseAlarm(root),
+                isHistorized, historianTagname, isArray, arrayLength);
+        }
+        catch (JsonException)
+        {
+            return new TagConfigIntent(tagConfig, null, null, false, null, false, null);
+        }
+    }
+
+    private static TagAlarmIntent? ParseAlarm(JsonElement root)
+    {
+        if (!root.TryGetProperty("alarm", out var a) || a.ValueKind != JsonValueKind.Object) return null;
+        var type = a.TryGetProperty("alarmType", out var tEl) && tEl.ValueKind == JsonValueKind.String
+            ? (tEl.GetString() ?? "AlarmCondition") : "AlarmCondition";
+        var sev = a.TryGetProperty("severity", out var sEl) && sEl.ValueKind == JsonValueKind.Number
+            && sEl.TryGetInt32(out var sv) ? sv : 500;
+        // historizeToAveva (bool?, absent ⇒ null ⇒ historize): only an explicit false suppresses the
+        // durable AVEVA write at the HistorianAdapterActor gate; a non-bool node ⇒ null (default-on).
+        bool? historize = a.TryGetProperty("historizeToAveva", out var hEl)
+                && hEl.ValueKind is JsonValueKind.True or JsonValueKind.False
+            ? hEl.GetBoolean()
+            : null;
+        return new TagAlarmIntent(type, sev, historize);
+    }
+
+    private static (bool IsHistorized, string? HistorianTagname) ParseHistorize(JsonElement root)
+    {
+        var isHistorized = root.TryGetProperty("isHistorized", out var hEl)
+            && (hEl.ValueKind == JsonValueKind.True || hEl.ValueKind == JsonValueKind.False)
+            && hEl.GetBoolean();
+        string? tagname = null;
+        if (root.TryGetProperty("historianTagname", out var nEl) && nEl.ValueKind == JsonValueKind.String)
+        {
+            var raw = nEl.GetString();
+            if (!string.IsNullOrWhiteSpace(raw)) tagname = raw; // not trimmed
+        }
+        return (isHistorized, tagname);
+    }
+
+    private static (bool IsArray, uint? ArrayLength) ParseArray(JsonElement root)
+    {
+        var isArray = root.TryGetProperty("isArray", out var aEl)
+            && (aEl.ValueKind == JsonValueKind.True || aEl.ValueKind == JsonValueKind.False)
+            && aEl.GetBoolean();
+        uint? arrayLength = null;
+        if (isArray
+            && root.TryGetProperty("arrayLength", out var lEl)
+            && lEl.ValueKind == JsonValueKind.Number
+            && lEl.TryGetUInt32(out var len))
+        {
+            arrayLength = len;
+        }
+        return (isArray, arrayLength);
+    }
+}
+
+/// <summary>The optional native-alarm intent parsed from a tag's <c>TagConfig.alarm</c> object.</summary>
+/// <param name="AlarmType">OPC UA Part 9 subtype string; default <c>"AlarmCondition"</c>.</param>
+/// <param name="Severity">1..1000 severity; default <c>500</c>.</param>
+/// <param name="HistorizeToAveva">Per-condition durable-write opt-out (<c>bool?</c>; absent ⇒ <see langword="null"/> ⇒ historize).</param>
+public sealed record TagAlarmIntent(string AlarmType, int Severity, bool? HistorizeToAveva);

src/Core/ZB.MOM.WW.OtOpcUa.Configuration/Validation/DraftValidator.cs

@@ -1,4 +1,5 @@
 using System.Text.RegularExpressions;
+using ZB.MOM.WW.OtOpcUa.Commons.Types;
 using ZB.MOM.WW.OtOpcUa.Configuration.Entities;
 using ZB.MOM.WW.OtOpcUa.Configuration.Enums;
 
@@ -47,29 +48,16 @@ public static class DraftValidator
             if (t.EquipmentId is null) continue;
             if (!typeByDriver.TryGetValue(t.DriverInstanceId, out var dtype) || dtype != "GalaxyMxGateway")
                 continue;
-            if (string.IsNullOrWhiteSpace(ExtractTagConfigFullName(t.TagConfig)))
+            // The Galaxy rule wants the EXPLICIT reference, not the raw-blob fallback — so it reads
+            // TagConfigIntent.ExplicitFullName (the "FullName" property only when present-and-string,
+            // else null), preserving the historical null-on-absent semantics by construction (R2-11).
+            if (string.IsNullOrWhiteSpace(TagConfigIntent.Parse(t.TagConfig).ExplicitFullName))
                 errors.Add(new("GalaxyTagMissingReference",
                     $"Galaxy tag '{t.TagId}' on equipment '{t.EquipmentId}' is missing a Galaxy reference (TagConfig.FullName)",
                     t.TagId));
         }
     }
 
-    // Minimal reader for the top-level "FullName" string in a tag's schemaless TagConfig JSON
-    // (mirrors AddressSpaceComposer.ExtractTagFullName — a small local copy, consistent with this codebase
-    // where the composer keeps its own).
-    private static string? ExtractTagConfigFullName(string? tagConfig)
-    {
-        if (string.IsNullOrWhiteSpace(tagConfig)) return null;
-        try
-        {
-            using var doc = System.Text.Json.JsonDocument.Parse(tagConfig);
-            return doc.RootElement.ValueKind == System.Text.Json.JsonValueKind.Object
-                && doc.RootElement.TryGetProperty("FullName", out var fn)
-                && fn.ValueKind == System.Text.Json.JsonValueKind.String ? fn.GetString() : null;
-        }
-        catch (System.Text.Json.JsonException) { return null; }
-    }
-
     private static void ValidateNoEquipmentSignalNameCollision(DraftSnapshot draft, List<ValidationError> errors)
     {
         // Materialiser NodeId key: "{EquipmentId}[/{FolderPath}]/{Name}". Tag (EquipmentId != null) and

src/Core/ZB.MOM.WW.OtOpcUa.Configuration/ZB.MOM.WW.OtOpcUa.Configuration.csproj

@@ -27,6 +27,9 @@
 
     <ItemGroup>
         <ProjectReference Include="..\ZB.MOM.WW.OtOpcUa.Core.Abstractions\ZB.MOM.WW.OtOpcUa.Core.Abstractions.csproj"/>
+        <!-- R2-11 (01/C-1): consume the shared TagConfigIntent.Parse byte-parity authority in Commons.
+             Cycle-safe — Commons has zero in-repo ProjectReferences. -->
+        <ProjectReference Include="..\ZB.MOM.WW.OtOpcUa.Commons\ZB.MOM.WW.OtOpcUa.Commons.csproj"/>
     </ItemGroup>
 
 </Project>

src/Core/ZB.MOM.WW.OtOpcUa.Core.Abstractions/TagConfigJson.cs

@@ -0,0 +1,100 @@
+using System.Text.Json;
+
+namespace ZB.MOM.WW.OtOpcUa.Core.Abstractions;
+
+/// <summary>The outcome of reading an enum-valued field from a TagConfig JSON object.</summary>
+public enum JsonEnumRead
+{
+    /// <summary>The property is absent, or present but not a JSON string (nothing to validate).</summary>
+    Absent,
+
+    /// <summary>The property is a JSON string that parses (case-insensitively) to the enum.</summary>
+    Valid,
+
+    /// <summary>The property is a JSON string that does NOT parse to the enum (a typo'd value).</summary>
+    Invalid,
+}
+
+/// <summary>
+///     Shared TagConfig JSON field readers for the six equipment-tag parsers (05/CONV-2). Replaces the
+///     six byte-identical private <c>ReadEnum</c> copies with one strict-capable home beside
+///     <see cref="EquipmentTagRefResolver{TDef}"/>.
+///     <para><b>Unknown-key handling is a deliberate non-goal.</b> The TagConfig blob is a SHARED
+///     namespace — platform intent keys (<c>FullName</c>, <c>alarm</c>, <c>isHistorized</c>, …) coexist
+///     with per-driver address keys (<c>region</c>, <c>dataType</c>, …) and forward-compat keys the typed
+///     editors preserve. There is no single canonical schema, so these readers read the known fields and
+///     ignore the rest; they NEVER warn on unknown keys.</para>
+/// </summary>
+public static class TagConfigJson
+{
+    /// <summary>
+    ///     Reads an enum-valued string field, distinguishing absent / valid / present-but-invalid so callers
+    ///     can be lenient (fall back) while still <em>reporting</em> the invalid case. A property that is
+    ///     absent or present-but-non-string yields <see cref="JsonEnumRead.Absent"/> (there is no enum
+    ///     string to validate); a present JSON string that parses case-insensitively yields
+    ///     <see cref="JsonEnumRead.Valid"/>; a present JSON string that does not parse yields
+    ///     <see cref="JsonEnumRead.Invalid"/>.
+    /// </summary>
+    /// <typeparam name="TEnum">The enum type to parse.</typeparam>
+    /// <param name="o">The TagConfig root object.</param>
+    /// <param name="name">The property name to read.</param>
+    /// <param name="value">The parsed enum on <see cref="JsonEnumRead.Valid"/>; otherwise <c>default</c>.</param>
+    /// <returns>The read outcome.</returns>
+    public static JsonEnumRead TryReadEnum<TEnum>(JsonElement o, string name, out TEnum value)
+        where TEnum : struct, Enum
+    {
+        if (!o.TryGetProperty(name, out var e) || e.ValueKind != JsonValueKind.String)
+        {
+            value = default;
+            return JsonEnumRead.Absent;
+        }
+        if (Enum.TryParse(e.GetString(), ignoreCase: true, out value))
+            return JsonEnumRead.Valid;
+        value = default;
+        return JsonEnumRead.Invalid;
+    }
+
+    /// <summary>
+    ///     Lenient enum read with today's exact semantics: absent OR invalid ⇒ <paramref name="fallback"/>;
+    ///     only a present, parseable string yields the parsed value. Bit-for-bit equivalent to the six
+    ///     retired private <c>ReadEnum</c> copies.
+    /// </summary>
+    /// <typeparam name="TEnum">The enum type to parse.</typeparam>
+    /// <param name="o">The TagConfig root object.</param>
+    /// <param name="name">The property name to read.</param>
+    /// <param name="fallback">The value returned when the field is absent or invalid.</param>
+    /// <returns>The parsed enum, or <paramref name="fallback"/>.</returns>
+    public static TEnum ReadEnumOrDefault<TEnum>(JsonElement o, string name, TEnum fallback)
+        where TEnum : struct, Enum
+        => TryReadEnum<TEnum>(o, name, out var v) == JsonEnumRead.Valid ? v : fallback;
+
+    /// <summary>
+    ///     Reads the optional <c>"writable"</c> flag with AbCip semantics (the model): an explicit JSON
+    ///     <c>false</c> ⇒ <see langword="false"/>; anything else (absent, <c>true</c>, or a non-bool token)
+    ///     ⇒ <paramref name="defaultValue"/>.
+    /// </summary>
+    /// <param name="o">The TagConfig root object.</param>
+    /// <param name="defaultValue">The value returned unless the field is an explicit JSON <c>false</c>.</param>
+    /// <returns><see langword="false"/> only for an explicit <c>false</c>; otherwise <paramref name="defaultValue"/>.</returns>
+    public static bool ReadWritable(JsonElement o, bool defaultValue = true)
+        => o.TryGetProperty("writable", out var e) && e.ValueKind == JsonValueKind.False
+            ? false
+            : defaultValue;
+
+    /// <summary>
+    ///     A human-readable warning for a present-but-invalid enum field (naming the field, the offending
+    ///     value, and the valid enum members), or <see langword="null"/> when the field is absent or valid.
+    /// </summary>
+    /// <typeparam name="TEnum">The enum type expected.</typeparam>
+    /// <param name="o">The TagConfig root object.</param>
+    /// <param name="name">The property name to describe.</param>
+    /// <returns>The warning text, or <see langword="null"/>.</returns>
+    public static string? DescribeInvalidEnum<TEnum>(JsonElement o, string name)
+        where TEnum : struct, Enum
+    {
+        if (TryReadEnum<TEnum>(o, name, out _) != JsonEnumRead.Invalid) return null;
+        var raw = o.TryGetProperty(name, out var e) ? e.GetString() : null;
+        var valid = string.Join(", ", Enum.GetNames<TEnum>());
+        return $"value '{raw}' for '{name}' is not a valid {typeof(TEnum).Name}; valid: {valid}";
+    }
+}

src/Core/ZB.MOM.WW.OtOpcUa.Core/OpcUa/EquipmentNodeWalker.cs

@@ -1,4 +1,4 @@
-using System.Text.Json;
+using ZB.MOM.WW.OtOpcUa.Commons.Types;
 using ZB.MOM.WW.OtOpcUa.Configuration.Entities;
 using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
 
@@ -190,22 +190,8 @@ public static class EquipmentNodeWalker
     /// </remarks>
     /// <param name="tagConfig">The tag configuration JSON or string.</param>
     /// <returns>The extracted <c>FullName</c> value, or the raw <paramref name="tagConfig"/> if it can't be extracted.</returns>
-    internal static string ExtractFullName(string tagConfig)
-    {
-        if (string.IsNullOrWhiteSpace(tagConfig)) return tagConfig;
-        try
-        {
-            using var doc = JsonDocument.Parse(tagConfig);
-            if (doc.RootElement.ValueKind == JsonValueKind.Object
-                && doc.RootElement.TryGetProperty("FullName", out var fullName)
-                && fullName.ValueKind == JsonValueKind.String)
-            {
-                return fullName.GetString() ?? tagConfig;
-            }
-        }
-        catch (JsonException) { /* fall through */ }
-        return tagConfig;
-    }
+    internal static string ExtractFullName(string tagConfig) =>
+        TagConfigIntent.Parse(tagConfig).FullName;
 
     /// <summary>
     ///     Parse <see cref="Tag.DataType"/> (stored as the <see cref="DriverDataType"/> enum

src/Core/ZB.MOM.WW.OtOpcUa.Core/ZB.MOM.WW.OtOpcUa.Core.csproj

@@ -14,6 +14,8 @@
     <ItemGroup>
         <ProjectReference Include="..\ZB.MOM.WW.OtOpcUa.Core.Abstractions\ZB.MOM.WW.OtOpcUa.Core.Abstractions.csproj"/>
         <ProjectReference Include="..\ZB.MOM.WW.OtOpcUa.Configuration\ZB.MOM.WW.OtOpcUa.Configuration.csproj"/>
+        <!-- R2-11: EquipmentNodeWalker.ExtractFullName delegates to the shared TagConfigIntent.Parse. -->
+        <ProjectReference Include="..\ZB.MOM.WW.OtOpcUa.Commons\ZB.MOM.WW.OtOpcUa.Commons.csproj"/>
     </ItemGroup>
 
     <ItemGroup>

src/Drivers/ZB.MOM.WW.OtOpcUa.Driver.AbCip.Contracts/AbCipEquipmentTagParser.cs

@@ -1,4 +1,5 @@
 using System.Text.Json;
+using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
 
 namespace ZB.MOM.WW.OtOpcUa.Driver.AbCip;
 
@@ -42,7 +43,7 @@ public static class AbCipEquipmentTagParser
             // resolves the full tag path (e.g. "Motor.Speed") without enumerating UDT members.
             // The address space emits a placeholder String variable; UDT member declarations are
             // not supported in the equipment-tag flow.
-            var dataType = ReadEnum(root, "dataType", AbCipDataType.DInt);
+            var dataType = TagConfigJson.ReadEnumOrDefault(root, "dataType", AbCipDataType.DInt);
             // Review I-1 — an equipment tag is an ARRAY ⟺ isArray:true AND arrayLength >= 1. A
             // 1-element array (isArray:true, arrayLength:1) is a VALID 1-element array — the
             // foundation materialises a [1] OPC UA array node — so it must read as an array, not a
@@ -50,8 +51,9 @@ public static class AbCipEquipmentTagParser
             // have a count of 1), so the explicit IsArray flag does.
             var (isArray, elementCount) = ReadArrayShape(root);
             // "writable" defaults to true when absent — matches AbCipTagDefinition.Writable default.
-            var writable = !root.TryGetProperty("writable", out var writableEl)
-                           || writableEl.ValueKind != JsonValueKind.False;
+            // Now via the shared TagConfigJson.ReadWritable (explicit-false-only), byte-identical to the
+            // hand-rolled read it replaces.
+            var writable = TagConfigJson.ReadWritable(root);
             def = new AbCipTagDefinition(
                 Name: reference, DeviceHostAddress: deviceHostAddress, TagPath: tagPath,
                 DataType: dataType, Writable: writable, ElementCount: elementCount, IsArray: isArray);
@@ -83,9 +85,35 @@ public static class AbCipEquipmentTagParser
         return (false, 1);
     }
 
-    private static TEnum ReadEnum<TEnum>(JsonElement o, string name, TEnum fallback) where TEnum : struct, Enum
-        => o.TryGetProperty(name, out var e) && e.ValueKind == JsonValueKind.String
-           && Enum.TryParse<TEnum>(e.GetString(), ignoreCase: true, out var v) ? v : fallback;
+    /// <summary>
+    ///     Deploy-time inspection (05/CONV-2): warns on a present-but-invalid <c>dataType</c> (silently
+    ///     defaulted by the lenient runtime) and on a structurally unparseable TagConfig. Empty when clean
+    ///     or not an equipment-tag object. Never throws.
+    /// </summary>
+    /// <param name="reference">The equipment tag's TagConfig JSON.</param>
+    /// <returns>The warnings; empty when clean.</returns>
+    public static IReadOnlyList<string> Inspect(string reference)
+    {
+        var warnings = new List<string>();
+        if (string.IsNullOrWhiteSpace(reference) || reference[0] != '{') return warnings;
+        try
+        {
+            using var doc = JsonDocument.Parse(reference);
+            var root = doc.RootElement;
+            if (root.ValueKind != JsonValueKind.Object)
+            {
+                warnings.Add("AbCip TagConfig root is not a JSON object — the tag will not resolve (BadNodeIdUnknown).");
+                return warnings;
+            }
+            var w = TagConfigJson.DescribeInvalidEnum<AbCipDataType>(root, "dataType");
+            if (w is not null) warnings.Add(w);
+        }
+        catch (JsonException)
+        {
+            warnings.Add("AbCip TagConfig is not valid JSON — the tag will not resolve (BadNodeIdUnknown).");
+        }
+        return warnings;
+    }
 
     private static string ReadString(JsonElement o, string name)
         => o.TryGetProperty(name, out var e) && e.ValueKind == JsonValueKind.String

src/Drivers/ZB.MOM.WW.OtOpcUa.Driver.AbCip.Contracts/ZB.MOM.WW.OtOpcUa.Driver.AbCip.Contracts.csproj

@@ -5,5 +5,9 @@
         <ImplicitUsings>enable</ImplicitUsings>
         <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     </PropertyGroup>
-    <!-- NO PackageReference. -->
+    <!-- NO PackageReference. ProjectReference only to the zero-dependency Core.Abstractions leaf
+         (R2-11 05/CONV-2 — shared TagConfigJson readers). -->
+    <ItemGroup>
+        <ProjectReference Include="..\..\Core\ZB.MOM.WW.OtOpcUa.Core.Abstractions\ZB.MOM.WW.OtOpcUa.Core.Abstractions.csproj"/>
+    </ItemGroup>
 </Project>

src/Drivers/ZB.MOM.WW.OtOpcUa.Driver.AbLegacy.Contracts/AbLegacyEquipmentTagParser.cs

@@ -1,4 +1,5 @@
 using System.Text.Json;
+using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
 
 namespace ZB.MOM.WW.OtOpcUa.Driver.AbLegacy;
 
@@ -38,7 +39,7 @@ public static class AbLegacyEquipmentTagParser
                 return false;
             var address = addr.GetString();
             if (string.IsNullOrWhiteSpace(address)) return false;
-            var dataType = ReadEnum(root, "dataType", AbLegacyDataType.Int);
+            var dataType = TagConfigJson.ReadEnumOrDefault(root, "dataType", AbLegacyDataType.Int);
             var deviceHostAddress = ReadString(root, "deviceHostAddress");
             int? arrayLength = null;
             if (IsArrayFlag(root))
@@ -47,9 +48,12 @@ public static class AbLegacyEquipmentTagParser
                 if (rawLength >= 1)
                     arrayLength = Math.Min(rawLength, AbLegacyArray.MaxElements);
             }
+            // "writable" defaults to true when absent (today's value) — makes read-only equipment tags
+            // authorable (UNDER-6).
+            var writable = TagConfigJson.ReadWritable(root);
             def = new AbLegacyTagDefinition(
                 Name: reference, DeviceHostAddress: deviceHostAddress, Address: address,
-                DataType: dataType, Writable: true, ArrayLength: arrayLength);
+                DataType: dataType, Writable: writable, ArrayLength: arrayLength);
             return true;
         }
         catch (JsonException) { return false; }
@@ -57,9 +61,35 @@ public static class AbLegacyEquipmentTagParser
         catch (InvalidOperationException) { return false; }
     }
 
-    private static TEnum ReadEnum<TEnum>(JsonElement o, string name, TEnum fallback) where TEnum : struct, Enum
-        => o.TryGetProperty(name, out var e) && e.ValueKind == JsonValueKind.String
-           && Enum.TryParse<TEnum>(e.GetString(), ignoreCase: true, out var v) ? v : fallback;
+    /// <summary>
+    ///     Deploy-time inspection (05/CONV-2): warns on a present-but-invalid <c>dataType</c> (silently
+    ///     defaulted by the lenient runtime) and on a structurally unparseable TagConfig. Empty when clean
+    ///     or not an equipment-tag object. Never throws.
+    /// </summary>
+    /// <param name="reference">The equipment tag's TagConfig JSON.</param>
+    /// <returns>The warnings; empty when clean.</returns>
+    public static IReadOnlyList<string> Inspect(string reference)
+    {
+        var warnings = new List<string>();
+        if (string.IsNullOrWhiteSpace(reference) || reference[0] != '{') return warnings;
+        try
+        {
+            using var doc = JsonDocument.Parse(reference);
+            var root = doc.RootElement;
+            if (root.ValueKind != JsonValueKind.Object)
+            {
+                warnings.Add("AbLegacy TagConfig root is not a JSON object — the tag will not resolve (BadNodeIdUnknown).");
+                return warnings;
+            }
+            var w = TagConfigJson.DescribeInvalidEnum<AbLegacyDataType>(root, "dataType");
+            if (w is not null) warnings.Add(w);
+        }
+        catch (JsonException)
+        {
+            warnings.Add("AbLegacy TagConfig is not valid JSON — the tag will not resolve (BadNodeIdUnknown).");
+        }
+        return warnings;
+    }
 
     private static string ReadString(JsonElement o, string name)
         => o.TryGetProperty(name, out var e) && e.ValueKind == JsonValueKind.String

src/Drivers/ZB.MOM.WW.OtOpcUa.Driver.AbLegacy.Contracts/ZB.MOM.WW.OtOpcUa.Driver.AbLegacy.Contracts.csproj

@@ -5,5 +5,9 @@
         <ImplicitUsings>enable</ImplicitUsings>
         <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     </PropertyGroup>
-    <!-- NO PackageReference. -->
+    <!-- NO PackageReference. ProjectReference only to the zero-dependency Core.Abstractions leaf
+         (R2-11 05/CONV-2 — shared TagConfigJson readers). -->
+    <ItemGroup>
+        <ProjectReference Include="..\..\Core\ZB.MOM.WW.OtOpcUa.Core.Abstractions\ZB.MOM.WW.OtOpcUa.Core.Abstractions.csproj"/>
+    </ItemGroup>
 </Project>

src/Drivers/ZB.MOM.WW.OtOpcUa.Driver.FOCAS.Contracts/FocasEquipmentTagParser.cs

@@ -1,4 +1,5 @@
 using System.Text.Json;
+using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
 
 namespace ZB.MOM.WW.OtOpcUa.Driver.FOCAS;
 
@@ -28,11 +29,17 @@ public static class FocasEquipmentTagParser
                 return false;
             var address = addr.GetString();
             if (string.IsNullOrWhiteSpace(address)) return false;
-            var dataType = ReadEnum(root, "dataType", FocasDataType.Int32);
+            var dataType = TagConfigJson.ReadEnumOrDefault(root, "dataType", FocasDataType.Int32);
             var deviceHostAddress = ReadString(root, "deviceHostAddress") ?? "";
             def = new FocasTagDefinition(
                 Name: reference, DeviceHostAddress: deviceHostAddress, Address: address,
-                DataType: dataType, Writable: true);
+                // FOCAS equipment tags are FORCED read-only (05/UNDER-1): the only wire client
+                // (WireFocasClient.cs:71-73) returns BadNotWritable for EVERY address, so advertising a
+                // writable node is a lie — a write that used to reach the backend and always fail with
+                // BadNotWritable now fails at the driver seam with the same family of Bad status (no
+                // successful operation changes). Any authored `writable:true` is ignored + warned by
+                // Inspect. Honour the key here once PMC writes ship in the wire client.
+                DataType: dataType, Writable: false);
             return true;
         }
         catch (JsonException) { return false; }
@@ -40,9 +47,38 @@ public static class FocasEquipmentTagParser
         catch (InvalidOperationException) { return false; }
     }
 
-    private static TEnum ReadEnum<TEnum>(JsonElement o, string name, TEnum fallback) where TEnum : struct, Enum
-        => o.TryGetProperty(name, out var e) && e.ValueKind == JsonValueKind.String
-           && Enum.TryParse<TEnum>(e.GetString(), ignoreCase: true, out var v) ? v : fallback;
+    /// <summary>
+    ///     Deploy-time inspection (05/CONV-2, 05/UNDER-1): warns on a present-but-invalid <c>dataType</c>
+    ///     (silently defaulted by the lenient runtime), on an authored <c>writable:true</c> (FOCAS writes
+    ///     are unsupported — the tag is forced read-only), and on a structurally unparseable TagConfig.
+    ///     Empty when clean or not an equipment-tag object. Never throws.
+    /// </summary>
+    /// <param name="reference">The equipment tag's TagConfig JSON.</param>
+    /// <returns>The warnings; empty when clean.</returns>
+    public static IReadOnlyList<string> Inspect(string reference)
+    {
+        var warnings = new List<string>();
+        if (string.IsNullOrWhiteSpace(reference) || reference[0] != '{') return warnings;
+        try
+        {
+            using var doc = JsonDocument.Parse(reference);
+            var root = doc.RootElement;
+            if (root.ValueKind != JsonValueKind.Object)
+            {
+                warnings.Add("FOCAS TagConfig root is not a JSON object — the tag will not resolve (BadNodeIdUnknown).");
+                return warnings;
+            }
+            var w = TagConfigJson.DescribeInvalidEnum<FocasDataType>(root, "dataType");
+            if (w is not null) warnings.Add(w);
+            if (root.TryGetProperty("writable", out var wr) && wr.ValueKind == JsonValueKind.True)
+                warnings.Add("FOCAS writes unsupported — 'writable:true' is ignored; the tag is forced read-only until PMC writes exist.");
+        }
+        catch (JsonException)
+        {
+            warnings.Add("FOCAS TagConfig is not valid JSON — the tag will not resolve (BadNodeIdUnknown).");
+        }
+        return warnings;
+    }
 
     private static string? ReadString(JsonElement o, string name)
         => o.TryGetProperty(name, out var e) && e.ValueKind == JsonValueKind.String ? e.GetString() : null;

src/Drivers/ZB.MOM.WW.OtOpcUa.Driver.FOCAS.Contracts/ZB.MOM.WW.OtOpcUa.Driver.FOCAS.Contracts.csproj

@@ -5,5 +5,10 @@
         <ImplicitUsings>enable</ImplicitUsings>
         <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     </PropertyGroup>
-    <!-- NO PackageReference. NO ProjectReference. -->
+    <!-- NO PackageReference. ProjectReference only to the zero-dependency Core.Abstractions leaf
+         (R2-11 05/CONV-2 — shared TagConfigJson readers beside EquipmentTagRefResolver; no
+         dependency-closure growth for lightweight AdminUI/Cli consumers). -->
+    <ItemGroup>
+        <ProjectReference Include="..\..\Core\ZB.MOM.WW.OtOpcUa.Core.Abstractions\ZB.MOM.WW.OtOpcUa.Core.Abstractions.csproj"/>
+    </ItemGroup>
 </Project>

src/Drivers/ZB.MOM.WW.OtOpcUa.Driver.FOCAS/FocasDriver.cs

@@ -68,7 +68,7 @@ public sealed class FocasDriver : IDriver, IReadable, IWritable, ITagDiscovery,
         _logger = logger ?? NullLogger<FocasDriver>.Instance;
         _resolver = new EquipmentTagRefResolver<FocasTagDefinition>(
             r => _tagsByName.TryGetValue(r, out var t) ? t : null,
-            r => FocasEquipmentTagParser.TryParse(r, out var d) ? d : null);
+            ResolveEquipmentTagRef);
         _poll = new PollGroupEngine(
             reader: ReadAsync,
             onChange: (handle, tagRef, snapshot) =>
@@ -234,6 +234,20 @@ public sealed class FocasDriver : IDriver, IReadable, IWritable, ITagDiscovery,
     internal bool IsParsedAddressCached(string reference) =>
         _parsedAddressesByTagName.ContainsKey(reference);
 
+    // Resolves an equipment-tag TagConfig reference into a FocasTagDefinition, applying the SAME
+    // capability pre-flight authored tags get at InitializeAsync (:105-119) — R2-11 (05/UNDER-6). A
+    // reference whose address is unparseable, whose bound device is unknown, or whose address violates
+    // the device series' capability matrix returns null ⇒ resolver miss ⇒ BadNodeIdUnknown at read time,
+    // instead of a wrong-status read reaching the wire. The negative is cached by the resolver.
+    private FocasTagDefinition? ResolveEquipmentTagRef(string reference)
+    {
+        if (!FocasEquipmentTagParser.TryParse(reference, out var def)) return null;
+        var parsed = FocasAddress.TryParse(def.Address);
+        if (parsed is null) return null;
+        if (!_devices.TryGetValue(def.DeviceHostAddress, out var device)) return null;
+        return FocasCapabilityMatrix.Validate(device.Options.Series, parsed) is null ? def : null;
+    }
+
     // Resolves a tag definition to its parsed FocasAddress, caching the result so that
     // equipment tags (resolver-produced, not seeded at InitializeAsync) don't re-parse the
     // address string on every ReadAsync / WriteAsync hot-path call.

src/Drivers/ZB.MOM.WW.OtOpcUa.Driver.Modbus.Contracts/ModbusEquipmentTagParser.cs

@@ -1,4 +1,5 @@
 using System.Text.Json;
+using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
 
 namespace ZB.MOM.WW.OtOpcUa.Driver.Modbus;
 
@@ -29,9 +30,9 @@ public static class ModbusEquipmentTagParser
                 || !addr.TryGetInt32(out var address)
                 || address < 0 || address > ushort.MaxValue)
                 return false;
-            var region = ReadEnum(root, "region", ModbusRegion.HoldingRegisters);
-            var dataType = ReadEnum(root, "dataType", ModbusDataType.Int16);
-            var byteOrder = ReadEnum(root, "byteOrder", ModbusByteOrder.BigEndian);
+            var region = TagConfigJson.ReadEnumOrDefault(root, "region", ModbusRegion.HoldingRegisters);
+            var dataType = TagConfigJson.ReadEnumOrDefault(root, "dataType", ModbusDataType.Int16);
+            var byteOrder = TagConfigJson.ReadEnumOrDefault(root, "byteOrder", ModbusByteOrder.BigEndian);
             var bitIndex = (byte)ReadInt(root, "bitIndex");
             var stringLength = (ushort)ReadInt(root, "stringLength");
             // Guard: String tags require StringLength >= 1. RegisterCount = (StringLength+1)/2,
@@ -51,9 +52,12 @@ public static class ModbusEquipmentTagParser
             var isArray = ReadBool(root, "isArray");
             var arrayLength = ReadInt(root, "arrayLength");
             int? arrayCount = (isArray && arrayLength >= 1) ? arrayLength : null;
+            // "writable" defaults to true when absent (today's value) — makes read-only equipment tags
+            // authorable (UNDER-6). Node-level authz remains the effective write gate.
+            var writable = TagConfigJson.ReadWritable(root);
             def = new ModbusTagDefinition(
                 Name: reference, Region: region, Address: (ushort)address, DataType: dataType,
-                Writable: true, ByteOrder: byteOrder, BitIndex: bitIndex, StringLength: stringLength,
+                Writable: writable, ByteOrder: byteOrder, BitIndex: bitIndex, StringLength: stringLength,
                 ArrayCount: arrayCount);
             return true;
         }
@@ -62,9 +66,44 @@ public static class ModbusEquipmentTagParser
         catch (InvalidOperationException) { return false; }
     }
 
-    private static TEnum ReadEnum<TEnum>(JsonElement o, string name, TEnum fallback) where TEnum : struct, Enum
-        => o.TryGetProperty(name, out var e) && e.ValueKind == JsonValueKind.String
-           && Enum.TryParse<TEnum>(e.GetString(), ignoreCase: true, out var v) ? v : fallback;
+    /// <summary>
+    ///     Deploy-time inspection of an equipment-tag <c>TagConfig</c> blob (05/CONV-2). Returns
+    ///     human-readable warnings for present-but-invalid enum values (<c>region</c> / <c>dataType</c> /
+    ///     <c>byteOrder</c> — which the lenient runtime silently defaults) and for a structurally
+    ///     unparseable TagConfig (which the runtime turns into a silent <c>BadNodeIdUnknown</c>). Empty when
+    ///     the blob is clean or is not an equipment-tag TagConfig object. Never throws.
+    /// </summary>
+    /// <param name="reference">The equipment tag's TagConfig JSON.</param>
+    /// <returns>The warnings; empty when clean.</returns>
+    public static IReadOnlyList<string> Inspect(string reference)
+    {
+        var warnings = new List<string>();
+        if (string.IsNullOrWhiteSpace(reference) || reference[0] != '{') return warnings;
+        try
+        {
+            using var doc = JsonDocument.Parse(reference);
+            var root = doc.RootElement;
+            if (root.ValueKind != JsonValueKind.Object)
+            {
+                warnings.Add("Modbus TagConfig root is not a JSON object — the tag will not resolve (BadNodeIdUnknown).");
+                return warnings;
+            }
+            foreach (var w in new[]
+            {
+                TagConfigJson.DescribeInvalidEnum<ModbusRegion>(root, "region"),
+                TagConfigJson.DescribeInvalidEnum<ModbusDataType>(root, "dataType"),
+                TagConfigJson.DescribeInvalidEnum<ModbusByteOrder>(root, "byteOrder"),
+            })
+            {
+                if (w is not null) warnings.Add(w);
+            }
+        }
+        catch (JsonException)
+        {
+            warnings.Add("Modbus TagConfig is not valid JSON — the tag will not resolve (BadNodeIdUnknown).");
+        }
+        return warnings;
+    }
 
     private static int ReadInt(JsonElement o, string name)
         => o.TryGetProperty(name, out var e) && e.ValueKind == JsonValueKind.Number

src/Drivers/ZB.MOM.WW.OtOpcUa.Driver.Modbus.Contracts/ZB.MOM.WW.OtOpcUa.Driver.Modbus.Contracts.csproj

@@ -12,6 +12,9 @@
          and was designed for exactly this use — Admin can reference it without transport-layer deps. -->
     <ItemGroup>
         <ProjectReference Include="..\ZB.MOM.WW.OtOpcUa.Driver.Modbus.Addressing\ZB.MOM.WW.OtOpcUa.Driver.Modbus.Addressing.csproj"/>
+        <!-- R2-11 (05/CONV-2): shared TagConfigJson field readers live in the zero-dependency
+             Core.Abstractions leaf beside EquipmentTagRefResolver. -->
+        <ProjectReference Include="..\..\Core\ZB.MOM.WW.OtOpcUa.Core.Abstractions\ZB.MOM.WW.OtOpcUa.Core.Abstractions.csproj"/>
     </ItemGroup>
 
 </Project>

src/Drivers/ZB.MOM.WW.OtOpcUa.Driver.Modbus/ModbusDriverProbe.cs

@@ -29,19 +29,44 @@ public sealed class ModbusDriverProbe : IDriverProbe
     /// <inheritdoc />
     public string DriverType => "Modbus";
 
+    /// <summary>The parsed probe target — host/port/unitId + the effective connection timeout, all read
+    /// from the SAME factory DTO shape (<c>ModbusDriverConfigDto</c>) the driver factory parses, so
+    /// <c>timeoutMs</c> binds identically to the factory (R2-11, 05/CONV-2; the OpcUaClient parity rule).</summary>
+    internal readonly record struct ProbeTarget(string Host, int Port, byte UnitId, TimeSpan Timeout);
+
+    /// <summary>Parse the driver config JSON into a <see cref="ProbeTarget"/> using the factory DTO shape.
+    /// Returns a null target + an error message when the JSON is invalid or has no host/port. The effective
+    /// timeout mirrors the factory (<c>TimeSpan.FromMilliseconds(dto.TimeoutMs ?? …)</c>); when the config
+    /// omits <c>timeoutMs</c> the caller's <paramref name="fallbackTimeout"/> is used.</summary>
+    /// <param name="configJson">The driver config JSON (factory DTO shape).</param>
+    /// <param name="fallbackTimeout">The timeout used when the config omits <c>timeoutMs</c>.</param>
+    /// <returns>The parsed target, or a null target with an error string.</returns>
+    internal static (ProbeTarget? Target, string? Error) TryParseProbeTarget(string configJson, TimeSpan fallbackTimeout)
+    {
+        ModbusDriverFactoryExtensions.ModbusDriverConfigDto? dto;
+        try { dto = JsonSerializer.Deserialize<ModbusDriverFactoryExtensions.ModbusDriverConfigDto>(configJson, _opts); }
+        catch (Exception ex) { return (null, $"Config JSON is invalid: {ex.Message}"); }
+        if (dto is null) return (null, "Config JSON deserialized to null.");
+
+        var port = dto.Port ?? 502;
+        if (string.IsNullOrWhiteSpace(dto.Host) || port <= 0)
+            return (null, "Config has no host/port to probe.");
+
+        var timeout = dto.TimeoutMs is { } ms && ms > 0 ? TimeSpan.FromMilliseconds(ms) : fallbackTimeout;
+        return (new ProbeTarget(dto.Host!, port, dto.UnitId ?? 1, timeout), null);
+    }
+
     /// <inheritdoc />
     public async Task<DriverProbeResult> ProbeAsync(string configJson, TimeSpan timeout, CancellationToken ct)
     {
-        ModbusDriverOptions? opts;
-        try { opts = JsonSerializer.Deserialize<ModbusDriverOptions>(configJson, _opts); }
-        catch (Exception ex) { return new(false, $"Config JSON is invalid: {ex.Message}", null); }
-        if (opts is null) return new(false, "Config JSON deserialized to null.", null);
+        var (target, error) = TryParseProbeTarget(configJson, timeout);
+        if (target is not { } t) return new(false, error!, null);
 
-        var (host, port) = ExtractTarget(opts);
-        if (string.IsNullOrWhiteSpace(host) || port <= 0)
-            return new(false, "Config has no host/port to probe.", null);
-
-        var unitId = opts.UnitId;
+        var host = t.Host;
+        var port = t.Port;
+        var unitId = t.UnitId;
+        // Honour the config's timeoutMs (factory parity) — the caller's timeout is the fallback.
+        timeout = t.Timeout;
 
         var sw = Stopwatch.StartNew();
         using var cts = CancellationTokenSource.CreateLinkedTokenSource(ct);
@@ -93,7 +118,4 @@ public sealed class ModbusDriverProbe : IDriverProbe
             }
         }
     }
-
-    private static (string host, int port) ExtractTarget(ModbusDriverOptions opts)
-        => (opts.Host, opts.Port);
 }

src/Drivers/ZB.MOM.WW.OtOpcUa.Driver.S7.Contracts/S7EquipmentTagParser.cs

@@ -1,4 +1,5 @@
 using System.Text.Json;
+using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
 
 namespace ZB.MOM.WW.OtOpcUa.Driver.S7;
 
@@ -31,7 +32,7 @@ public static class S7EquipmentTagParser
                 return false;
             var address = addrEl.GetString();
             if (string.IsNullOrWhiteSpace(address)) return false;
-            var dataType = ReadEnum(root, "dataType", S7DataType.Int16);
+            var dataType = TagConfigJson.ReadEnumOrDefault(root, "dataType", S7DataType.Int16);
             var stringLength = ReadInt(root, "stringLength");
             // Range-guard applies only to String tags: an S7 string can't exceed 254 chars, and a
             // negative length is meaningless. For non-String types stringLength is irrelevant and any
@@ -42,11 +43,14 @@ public static class S7EquipmentTagParser
             // that here so the driver's transient def agrees byte-for-byte with the materialised
             // OPC UA node's ValueRank/ArrayDimensions. Absent / isArray=false ⇒ null (scalar).
             var arrayCount = ReadArrayCount(root);
+            // "writable" defaults to true when absent (today's value); node-level authz still governs
+            // writes. Honouring the key makes read-only equipment tags authorable (UNDER-6).
+            var writable = TagConfigJson.ReadWritable(root);
             def = new S7TagDefinition(
                 Name: reference,
                 Address: address,
                 DataType: dataType,
-                Writable: true, // node-level authz governs writes
+                Writable: writable,
                 StringLength: stringLength == 0 ? MaxStringLength : stringLength,
                 ArrayCount: arrayCount);
             return true;
@@ -56,9 +60,35 @@ public static class S7EquipmentTagParser
         catch (InvalidOperationException) { return false; }
     }
 
-    private static TEnum ReadEnum<TEnum>(JsonElement o, string name, TEnum fallback) where TEnum : struct, Enum
-        => o.TryGetProperty(name, out var e) && e.ValueKind == JsonValueKind.String
-           && Enum.TryParse<TEnum>(e.GetString(), ignoreCase: true, out var v) ? v : fallback;
+    /// <summary>
+    ///     Deploy-time inspection (05/CONV-2): warns on a present-but-invalid <c>dataType</c> (silently
+    ///     defaulted by the lenient runtime) and on a structurally unparseable TagConfig (a silent
+    ///     <c>BadNodeIdUnknown</c> at runtime). Empty when clean or not an equipment-tag object. Never throws.
+    /// </summary>
+    /// <param name="reference">The equipment tag's TagConfig JSON.</param>
+    /// <returns>The warnings; empty when clean.</returns>
+    public static IReadOnlyList<string> Inspect(string reference)
+    {
+        var warnings = new List<string>();
+        if (string.IsNullOrWhiteSpace(reference) || reference[0] != '{') return warnings;
+        try
+        {
+            using var doc = JsonDocument.Parse(reference);
+            var root = doc.RootElement;
+            if (root.ValueKind != JsonValueKind.Object)
+            {
+                warnings.Add("S7 TagConfig root is not a JSON object — the tag will not resolve (BadNodeIdUnknown).");
+                return warnings;
+            }
+            var w = TagConfigJson.DescribeInvalidEnum<S7DataType>(root, "dataType");
+            if (w is not null) warnings.Add(w);
+        }
+        catch (JsonException)
+        {
+            warnings.Add("S7 TagConfig is not valid JSON — the tag will not resolve (BadNodeIdUnknown).");
+        }
+        return warnings;
+    }
 
     private static int ReadInt(JsonElement o, string name)
         => o.TryGetProperty(name, out var e) && e.ValueKind == JsonValueKind.Number

src/Drivers/ZB.MOM.WW.OtOpcUa.Driver.S7.Contracts/ZB.MOM.WW.OtOpcUa.Driver.S7.Contracts.csproj

@@ -7,6 +7,11 @@
         <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     </PropertyGroup>
 
-    <!-- NO PackageReference. NO ProjectReference. -->
+    <!-- NO PackageReference. ProjectReference only to the zero-dependency Core.Abstractions leaf
+         (R2-11 05/CONV-2 — shared TagConfigJson readers beside EquipmentTagRefResolver; adds no
+         dependency-closure growth for lightweight AdminUI/Cli consumers). -->
+    <ItemGroup>
+        <ProjectReference Include="..\..\Core\ZB.MOM.WW.OtOpcUa.Core.Abstractions\ZB.MOM.WW.OtOpcUa.Core.Abstractions.csproj"/>
+    </ItemGroup>
 
 </Project>

src/Drivers/ZB.MOM.WW.OtOpcUa.Driver.TwinCAT.Contracts/TwinCATEquipmentTagParser.cs

@@ -1,4 +1,5 @@
 using System.Text.Json;
+using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
 
 namespace ZB.MOM.WW.OtOpcUa.Driver.TwinCAT;
 
@@ -28,15 +29,18 @@ public static class TwinCATEquipmentTagParser
             var symbolPath = symbol.GetString();
             if (string.IsNullOrWhiteSpace(symbolPath)) return false;
             var deviceHostAddress = ReadString(root, "deviceHostAddress");
-            var dataType = ReadEnum(root, "dataType", TwinCATDataType.DInt);
+            var dataType = TagConfigJson.ReadEnumOrDefault(root, "dataType", TwinCATDataType.DInt);
             // Array intent — same shape the runtime/OPC-UA foundation parses (camelCase
             // `isArray` bool + `arrayLength` uint). arrayLength is honoured ONLY when isArray
             // is true AND it is a positive JSON number, so a stale length behind a cleared
             // isArray never produces an orphan array tag (Phase 4c).
             var arrayLength = ReadArrayLength(root);
+            // "writable" defaults to true when absent (today's value) — makes read-only equipment tags
+            // authorable (UNDER-6).
+            var writable = TagConfigJson.ReadWritable(root);
             def = new TwinCATTagDefinition(
                 Name: reference, DeviceHostAddress: deviceHostAddress, SymbolPath: symbolPath,
-                DataType: dataType, Writable: true, ArrayLength: arrayLength);
+                DataType: dataType, Writable: writable, ArrayLength: arrayLength);
             return true;
         }
         catch (JsonException) { return false; }
@@ -44,9 +48,35 @@ public static class TwinCATEquipmentTagParser
         catch (InvalidOperationException) { return false; }
     }
 
-    private static TEnum ReadEnum<TEnum>(JsonElement o, string name, TEnum fallback) where TEnum : struct, Enum
-        => o.TryGetProperty(name, out var e) && e.ValueKind == JsonValueKind.String
-           && Enum.TryParse<TEnum>(e.GetString(), ignoreCase: true, out var v) ? v : fallback;
+    /// <summary>
+    ///     Deploy-time inspection (05/CONV-2): warns on a present-but-invalid <c>dataType</c> (silently
+    ///     defaulted by the lenient runtime) and on a structurally unparseable TagConfig. Empty when clean
+    ///     or not an equipment-tag object. Never throws.
+    /// </summary>
+    /// <param name="reference">The equipment tag's TagConfig JSON.</param>
+    /// <returns>The warnings; empty when clean.</returns>
+    public static IReadOnlyList<string> Inspect(string reference)
+    {
+        var warnings = new List<string>();
+        if (string.IsNullOrWhiteSpace(reference) || reference[0] != '{') return warnings;
+        try
+        {
+            using var doc = JsonDocument.Parse(reference);
+            var root = doc.RootElement;
+            if (root.ValueKind != JsonValueKind.Object)
+            {
+                warnings.Add("TwinCAT TagConfig root is not a JSON object — the tag will not resolve (BadNodeIdUnknown).");
+                return warnings;
+            }
+            var w = TagConfigJson.DescribeInvalidEnum<TwinCATDataType>(root, "dataType");
+            if (w is not null) warnings.Add(w);
+        }
+        catch (JsonException)
+        {
+            warnings.Add("TwinCAT TagConfig is not valid JSON — the tag will not resolve (BadNodeIdUnknown).");
+        }
+        return warnings;
+    }
 
     private static string ReadString(JsonElement o, string name)
         => o.TryGetProperty(name, out var e) && e.ValueKind == JsonValueKind.String

src/Drivers/ZB.MOM.WW.OtOpcUa.Driver.TwinCAT.Contracts/ZB.MOM.WW.OtOpcUa.Driver.TwinCAT.Contracts.csproj

@@ -5,5 +5,9 @@
         <ImplicitUsings>enable</ImplicitUsings>
         <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     </PropertyGroup>
-    <!-- NO PackageReference. -->
+    <!-- NO PackageReference. ProjectReference only to the zero-dependency Core.Abstractions leaf
+         (R2-11 05/CONV-2 — shared TagConfigJson readers). -->
+    <ItemGroup>
+        <ProjectReference Include="..\..\Core\ZB.MOM.WW.OtOpcUa.Core.Abstractions\ZB.MOM.WW.OtOpcUa.Core.Abstractions.csproj"/>
+    </ItemGroup>
 </Project>

src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Shared/Uns/TagEditors/AbCipTagConfigEditor.razor

@@ -17,6 +17,14 @@
         <select class="form-select form-select-sm" value="@_m.DataType" @onchange="@(e => Update(() => _m.DataType = ParseEnum(e.Value, AbCipDataType.DInt)))">
             @foreach (var v in Enum.GetValues<AbCipDataType>()) { <option value="@v">@v</option> }
         </select></div>
+    <div class="col-12">
+        <div class="form-check">
+            <input type="checkbox" class="form-check-input" id="abcip-writable"
+                   checked="@(_m.Writable ?? true)"
+                   @onchange="@(e => Update(() => _m.Writable = e.Value is bool b && b))" />
+            <label class="form-check-label small" for="abcip-writable">Writable (uncheck for a read-only tag)</label>
+        </div>
+    </div>
 </div>
 
 @if (_showPicker)

src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Shared/Uns/TagEditors/AbLegacyTagConfigEditor.razor

@@ -17,6 +17,14 @@
         <select class="form-select form-select-sm" value="@_m.DataType" @onchange="@(e => Update(() => _m.DataType = ParseEnum(e.Value, AbLegacyDataType.Int)))">
             @foreach (var v in Enum.GetValues<AbLegacyDataType>()) { <option value="@v">@v</option> }
         </select></div>
+    <div class="col-12">
+        <div class="form-check">
+            <input type="checkbox" class="form-check-input" id="ablegacy-writable"
+                   checked="@(_m.Writable ?? true)"
+                   @onchange="@(e => Update(() => _m.Writable = e.Value is bool b && b))" />
+            <label class="form-check-label small" for="ablegacy-writable">Writable (uncheck for a read-only tag)</label>
+        </div>
+    </div>
 </div>
 
 @if (_showPicker)

src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Shared/Uns/TagEditors/FocasTagConfigEditor.razor

@@ -17,6 +17,12 @@
         <select class="form-select form-select-sm" value="@_m.DataType" @onchange="@(e => Update(() => _m.DataType = ParseEnum(e.Value, FocasDataType.Int32)))">
             @foreach (var v in Enum.GetValues<FocasDataType>()) { <option value="@v">@v</option> }
         </select></div>
+    <div class="col-12">
+        <div class="form-check">
+            <input type="checkbox" class="form-check-input" id="focas-writable" disabled checked="false" />
+            <label class="form-check-label small text-muted" for="focas-writable">Writable — FOCAS writes are unsupported; tags are read-only.</label>
+        </div>
+    </div>
 </div>
 
 @if (_showPicker)

src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Shared/Uns/TagEditors/ModbusTagConfigEditor.razor

@@ -25,6 +25,14 @@
     <div class="col-12 mt-1">
         <button type="button" class="btn btn-sm btn-outline-secondary" @onclick="@(() => _showPicker = true)">Build address</button>
     </div>
+    <div class="col-12">
+        <div class="form-check">
+            <input type="checkbox" class="form-check-input" id="modbus-writable"
+                   checked="@(_m.Writable ?? true)"
+                   @onchange="@(e => Update(() => _m.Writable = e.Value is bool b && b))" />
+            <label class="form-check-label small" for="modbus-writable">Writable (uncheck for a read-only tag)</label>
+        </div>
+    </div>
 </div>
 
 @if (_showPicker)

src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Shared/Uns/TagEditors/S7TagConfigEditor.razor

@@ -17,6 +17,14 @@
         </select></div>
     <div class="col-md-3"><label class="form-label">String len</label>
         <input type="number" class="form-control form-control-sm" value="@_m.StringLength" @onchange="@(e => Update(() => _m.StringLength = ParseInt(e.Value)))" /></div>
+    <div class="col-12">
+        <div class="form-check">
+            <input type="checkbox" class="form-check-input" id="s7-writable"
+                   checked="@(_m.Writable ?? true)"
+                   @onchange="@(e => Update(() => _m.Writable = e.Value is bool b && b))" />
+            <label class="form-check-label small" for="s7-writable">Writable (uncheck for a read-only tag)</label>
+        </div>
+    </div>
 </div>
 
 @if (_showPicker)

src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Components/Shared/Uns/TagEditors/TwinCATTagConfigEditor.razor

@@ -17,6 +17,14 @@
         <select class="form-select form-select-sm" value="@_m.DataType" @onchange="@(e => Update(() => _m.DataType = ParseEnum(e.Value, TwinCATDataType.DInt)))">
             @foreach (var v in Enum.GetValues<TwinCATDataType>()) { <option value="@v">@v</option> }
         </select></div>
+    <div class="col-12">
+        <div class="form-check">
+            <input type="checkbox" class="form-check-input" id="twincat-writable"
+                   checked="@(_m.Writable ?? true)"
+                   @onchange="@(e => Update(() => _m.Writable = e.Value is bool b && b))" />
+            <label class="form-check-label small" for="twincat-writable">Writable (uncheck for a read-only tag)</label>
+        </div>
+    </div>
 </div>
 
 @if (_showPicker)

src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/ScriptAnalysis/IScriptTagCatalog.cs

@@ -53,7 +53,7 @@ public sealed record ScriptTagInfo(string Path, string Kind, string DataType, st
 ///         <c>DriverInstanceActor.AttributeValuePublished.FullReference</c>
 ///         (<c>src/Server/…Runtime/VirtualTags/DependencyMuxActor.cs:97</c>) — and that
 ///         <c>FullReference</c> is the <c>FullName</c> field extracted from <c>Tag.TagConfig</c>
-///         (see <c>AddressSpaceComposer.ExtractTagFullName</c> + <c>EquipmentNodeWalker.ExtractFullName</c>).
+///         (see <c>Commons.Types.TagConfigIntent.Parse</c>, the shared byte-parity FullName authority).
 ///         The UNS-path engine (<c>Core.VirtualTags.VirtualTagEngine</c>, keyed by a slash-joined
 ///         <c>Enterprise/Site/Area/Line/Equipment/TagName</c>) is dormant — it is NOT wired into the
 ///         host — so UNS browse paths never resolve at runtime and are intentionally NOT suggested.
@@ -179,8 +179,8 @@ public sealed class ScriptTagCatalog(IDbContextFactory<OtOpcUaConfigDbContext> d
     /// <summary>
     ///     Extracts the driver-side full reference from a <c>Tag.TagConfig</c> JSON blob — the
     ///     top-level <c>FullName</c> string every shipped driver stores. Mirrors
-    ///     <c>EquipmentNodeWalker.ExtractFullName</c> / <c>AddressSpaceComposer.ExtractTagFullName</c>
-    ///     (AdminUI does not reference those assemblies). Falls back to the raw blob when it is not
+    ///     <c>Commons.Types.TagConfigIntent.Parse(...).FullName</c> (the shared byte-parity authority;
+    ///     AdminUI does not reference that assembly here). Falls back to the raw blob when it is not
     ///     a JSON object carrying a string <c>FullName</c>.
     /// </summary>
     private static string ExtractFullNameFromTagConfig(string tagConfig)

src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/TagEditors/AbCipTagConfigModel.cs

@@ -16,6 +16,10 @@ public sealed class AbCipTagConfigModel
     /// <summary>Logix atomic type, or <c>AbCipDataType.Structure</c> for UDT-typed tags.</summary>
     public AbCipDataType DataType { get; set; } = AbCipDataType.DInt;
 
+    /// <summary>Optional writable flag (R2-11); <c>null</c> ⇒ omitted (driver default true), explicit
+    /// <c>false</c> ⇒ read-only. Preserved across load→save.</summary>
+    public bool? Writable { get; set; }
+
     private JsonObject _bag = new();
 
     /// <summary>Loads a model from a TagConfig JSON string, defaulting any absent field and retaining
@@ -30,6 +34,7 @@ public sealed class AbCipTagConfigModel
             DeviceHostAddress = TagConfigJson.GetString(o, "deviceHostAddress") ?? "",
             TagPath = TagConfigJson.GetString(o, "tagPath") ?? "",
             DataType = TagConfigJson.GetEnum(o, "dataType", AbCipDataType.DInt),
+            Writable = TagConfigJson.GetBoolNullable(o, "writable"),
             _bag = o,
         };
     }
@@ -42,6 +47,7 @@ public sealed class AbCipTagConfigModel
         TagConfigJson.Set(_bag, "deviceHostAddress", string.IsNullOrWhiteSpace(DeviceHostAddress) ? null : DeviceHostAddress.Trim());
         TagConfigJson.Set(_bag, "tagPath", TagPath.Trim());
         TagConfigJson.Set(_bag, "dataType", DataType);
+        TagConfigJson.Set(_bag, "writable", Writable);
         return TagConfigJson.Serialize(_bag);
     }
 

src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/TagEditors/AbLegacyTagConfigModel.cs

@@ -16,6 +16,10 @@ public sealed class AbLegacyTagConfigModel
     /// <summary>PCCC data type that maps onto SLC / MicroLogix / PLC-5 files.</summary>
     public AbLegacyDataType DataType { get; set; } = AbLegacyDataType.Int;
 
+    /// <summary>Optional writable flag (R2-11); <c>null</c> ⇒ omitted (driver default true), explicit
+    /// <c>false</c> ⇒ read-only. Preserved across load→save.</summary>
+    public bool? Writable { get; set; }
+
     private JsonObject _bag = new();
 
     /// <summary>Loads a model from a TagConfig JSON string, defaulting any absent field and retaining
@@ -30,6 +34,7 @@ public sealed class AbLegacyTagConfigModel
             DeviceHostAddress = TagConfigJson.GetString(o, "deviceHostAddress") ?? "",
             Address = TagConfigJson.GetString(o, "address") ?? "",
             DataType = TagConfigJson.GetEnum(o, "dataType", AbLegacyDataType.Int),
+            Writable = TagConfigJson.GetBoolNullable(o, "writable"),
             _bag = o,
         };
     }
@@ -42,6 +47,7 @@ public sealed class AbLegacyTagConfigModel
         TagConfigJson.Set(_bag, "deviceHostAddress", string.IsNullOrWhiteSpace(DeviceHostAddress) ? null : DeviceHostAddress.Trim());
         TagConfigJson.Set(_bag, "address", Address.Trim());
         TagConfigJson.Set(_bag, "dataType", DataType);
+        TagConfigJson.Set(_bag, "writable", Writable);
         return TagConfigJson.Serialize(_bag);
     }
 

src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/TagEditors/ModbusTagConfigModel.cs

@@ -25,6 +25,11 @@ public sealed class ModbusTagConfigModel
     /// <summary>String length in characters for String tags.</summary>
     public int StringLength { get; set; }
 
+    /// <summary>Optional writable flag (R2-11). <c>null</c> ⇒ the key is omitted (driver default true);
+    /// an explicit <c>false</c> makes the equipment tag read-only. Preserved across load→save so an absent
+    /// key stays absent.</summary>
+    public bool? Writable { get; set; }
+
     private JsonObject _bag = new();
 
     /// <summary>Loads a model from a TagConfig JSON string, defaulting any absent field and retaining
@@ -42,6 +47,7 @@ public sealed class ModbusTagConfigModel
             ByteOrder = TagConfigJson.GetEnum(o, "byteOrder", ModbusByteOrder.BigEndian),
             BitIndex = TagConfigJson.GetInt(o, "bitIndex"),
             StringLength = TagConfigJson.GetInt(o, "stringLength"),
+            Writable = TagConfigJson.GetBoolNullable(o, "writable"),
             _bag = o,
         };
     }
@@ -57,6 +63,7 @@ public sealed class ModbusTagConfigModel
         TagConfigJson.Set(_bag, "byteOrder", ByteOrder);
         TagConfigJson.Set(_bag, "bitIndex", BitIndex);
         TagConfigJson.Set(_bag, "stringLength", StringLength);
+        TagConfigJson.Set(_bag, "writable", Writable);
         return TagConfigJson.Serialize(_bag);
     }
 

src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/TagEditors/OpcUaClientTagConfigModel.cs

@@ -7,9 +7,9 @@ namespace ZB.MOM.WW.OtOpcUa.AdminUI.Uns.TagEditors;
 /// stable <c>nsu=…;s=…</c> or plain <c>ns=2;s=…</c> NodeId the driver reads/writes/subscribes against).
 /// Preserves unrecognised JSON keys across a load→save.</summary>
 /// <remarks>
-///     The <c>FullName</c> key is intentionally PascalCase: the deploy-time composer + node walker
-///     (<c>AddressSpaceComposer.ExtractTagFullName</c>, <c>EquipmentNodeWalker</c>) read it via a
-///     case-sensitive <c>TryGetProperty("FullName", …)</c>, so the editor MUST persist that exact
+///     The <c>FullName</c> key is intentionally PascalCase: the shared deploy-time parser
+///     (<c>Commons.Types.TagConfigIntent.Parse</c>, consumed by the composer, artifact decoder, draft
+///     gate, and node walker) reads it via a case-sensitive <c>TryGetProperty("FullName", …)</c>, so the editor MUST persist that exact
 ///     casing. The driver-agnostic server-side HistoryRead intent keys (<c>isHistorized</c> /
 ///     <c>historianTagname</c>) are NOT modelled here — they are owned by the TagModal-merge seam
 ///     (<see cref="TagHistorizeConfig"/>) and survive a load→save of this model as preserved unknown keys.

src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/TagEditors/S7TagConfigModel.cs

@@ -16,6 +16,10 @@ public sealed class S7TagConfigModel
     /// <summary>For <c>DataType = String</c>: S7-string max length (max 254).</summary>
     public int StringLength { get; set; }
 
+    /// <summary>Optional writable flag (R2-11); <c>null</c> ⇒ omitted (driver default true), explicit
+    /// <c>false</c> ⇒ read-only. Preserved across load→save.</summary>
+    public bool? Writable { get; set; }
+
     private JsonObject _bag = new();
 
     /// <summary>Loads a model from a TagConfig JSON string, defaulting any absent field and retaining
@@ -30,6 +34,7 @@ public sealed class S7TagConfigModel
             Address = TagConfigJson.GetString(o, "address") ?? "",
             DataType = TagConfigJson.GetEnum(o, "dataType", S7DataType.Int16),
             StringLength = TagConfigJson.GetInt(o, "stringLength"),
+            Writable = TagConfigJson.GetBoolNullable(o, "writable"),
             _bag = o,
         };
     }
@@ -42,6 +47,7 @@ public sealed class S7TagConfigModel
         TagConfigJson.Set(_bag, "address", Address.Trim());
         TagConfigJson.Set(_bag, "dataType", DataType);
         TagConfigJson.Set(_bag, "stringLength", StringLength);
+        TagConfigJson.Set(_bag, "writable", Writable);
         return TagConfigJson.Serialize(_bag);
     }
 

src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/TagEditors/TagConfigJson.cs

@@ -48,6 +48,14 @@ public static class TagConfigJson
     public static bool GetBool(JsonObject o, string name, bool fallback = false)
         => o.TryGetPropertyValue(name, out var n) && n is JsonValue v && v.TryGetValue<bool>(out var b) ? b : fallback;
 
+    /// <summary>Reads a bool value, or <c>null</c> when the property is absent/null/non-boolean — so an
+    /// absent key stays absent through a load→save (distinguishes "not set" from an explicit false).</summary>
+    /// <param name="o">The JSON object to read from.</param>
+    /// <param name="name">The property name to read.</param>
+    /// <returns>The bool value, or <c>null</c> when absent/null/non-boolean.</returns>
+    public static bool? GetBoolNullable(JsonObject o, string name)
+        => o.TryGetPropertyValue(name, out var n) && n is JsonValue v && v.TryGetValue<bool>(out var b) ? b : null;
+
     /// <summary>Reads an enum by its serialised name, or <paramref name="fallback"/> if absent/unparseable.</summary>
     /// <typeparam name="TEnum">The enum type to parse.</typeparam>
     /// <param name="o">The JSON object to read from.</param>

src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/TagEditors/TwinCATTagConfigModel.cs

@@ -16,6 +16,10 @@ public sealed class TwinCATTagConfigModel
     /// <summary>TwinCAT / IEC 61131-3 atomic data type.</summary>
     public TwinCATDataType DataType { get; set; } = TwinCATDataType.DInt;
 
+    /// <summary>Optional writable flag (R2-11); <c>null</c> ⇒ omitted (driver default true), explicit
+    /// <c>false</c> ⇒ read-only. Preserved across load→save.</summary>
+    public bool? Writable { get; set; }
+
     private JsonObject _bag = new();
 
     /// <summary>Loads a model from a TagConfig JSON string, defaulting any absent field and retaining
@@ -30,6 +34,7 @@ public sealed class TwinCATTagConfigModel
             DeviceHostAddress = TagConfigJson.GetString(o, "deviceHostAddress") ?? "",
             SymbolPath = TagConfigJson.GetString(o, "symbolPath") ?? "",
             DataType = TagConfigJson.GetEnum(o, "dataType", TwinCATDataType.DInt),
+            Writable = TagConfigJson.GetBoolNullable(o, "writable"),
             _bag = o,
         };
     }
@@ -42,6 +47,7 @@ public sealed class TwinCATTagConfigModel
         TagConfigJson.Set(_bag, "deviceHostAddress", string.IsNullOrWhiteSpace(DeviceHostAddress) ? null : DeviceHostAddress.Trim());
         TagConfigJson.Set(_bag, "symbolPath", SymbolPath.Trim());
         TagConfigJson.Set(_bag, "dataType", DataType);
+        TagConfigJson.Set(_bag, "writable", Writable);
         return TagConfigJson.Serialize(_bag);
     }
 

src/Server/ZB.MOM.WW.OtOpcUa.ControlPlane/AdminOperations/AdminOperationsActor.cs

@@ -25,31 +25,37 @@ public sealed class AdminOperationsActor : ReceiveActor
     private readonly IDbContextFactory<OtOpcUaConfigDbContext> _dbFactory;
     private readonly IActorRef _coordinator;
     private readonly IReadOnlyDictionary<string, IDriverProbe> _probesByType;
+    private readonly TagConfigValidationMode _tagConfigValidationMode;
     private readonly ILoggingAdapter _log = Context.GetLogger();
 
     /// <summary>Creates actor props for the admin operations actor.</summary>
     /// <param name="dbFactory">Factory for creating config database contexts.</param>
     /// <param name="coordinator">Reference to the deployment coordinator actor.</param>
     /// <param name="probes">Driver probes registered in DI; keyed by DriverType (case-insensitive).</param>
+    /// <param name="tagConfigValidationMode">Deploy-gate TagConfig strictness mode (Warn default | Error opt-in).</param>
     /// <returns>Props configured to create an AdminOperationsActor.</returns>
     public static Props Props(
         IDbContextFactory<OtOpcUaConfigDbContext> dbFactory,
         IActorRef coordinator,
-        IEnumerable<IDriverProbe> probes) =>
-        Akka.Actor.Props.Create(() => new AdminOperationsActor(dbFactory, coordinator, probes));
+        IEnumerable<IDriverProbe> probes,
+        TagConfigValidationMode tagConfigValidationMode = TagConfigValidationMode.Warn) =>
+        Akka.Actor.Props.Create(() => new AdminOperationsActor(dbFactory, coordinator, probes, tagConfigValidationMode));
 
     /// <summary>Initializes a new instance of the AdminOperationsActor.</summary>
     /// <param name="dbFactory">Factory for creating config database contexts.</param>
     /// <param name="coordinator">Reference to the deployment coordinator actor.</param>
     /// <param name="probes">Driver probes registered in DI; keyed by DriverType (case-insensitive).</param>
+    /// <param name="tagConfigValidationMode">Deploy-gate TagConfig strictness mode (Warn default | Error opt-in).</param>
     public AdminOperationsActor(
         IDbContextFactory<OtOpcUaConfigDbContext> dbFactory,
         IActorRef coordinator,
-        IEnumerable<IDriverProbe> probes)
+        IEnumerable<IDriverProbe> probes,
+        TagConfigValidationMode tagConfigValidationMode = TagConfigValidationMode.Warn)
     {
         _dbFactory = dbFactory;
         _coordinator = coordinator;
         _probesByType = probes.ToDictionary(p => p.DriverType, StringComparer.OrdinalIgnoreCase);
+        _tagConfigValidationMode = tagConfigValidationMode;
 
         ReceiveAsync<StartDeployment>(HandleStartDeploymentAsync);
         ReceiveAsync<TestDriverConnect>(HandleTestDriverConnectAsync);
@@ -202,6 +208,31 @@ public sealed class AdminOperationsActor : ReceiveActor
                 errors.AddRange(DraftValidator.ValidateClusterTopology(cluster, nodes));
             }
 
+            // R2-11 (05/CONV-2): deploy-time TagConfig strictness inspection over equipment tags. The
+            // driver-typed EquipmentTagConfigInspector surfaces present-but-invalid enum values (which the
+            // lenient runtime silently defaults) + structurally-unparseable TagConfig. In Warn mode
+            // (default) these are non-blocking (logged + appended to the accepted result Message); in Error
+            // mode they fold into the reject list so a typo'd config cannot be re-deployed until fixed.
+            // Running servers are untouched either way — the gate only sees re-deploys.
+            var driverTypeById = draft.DriverInstances
+                .GroupBy(d => d.DriverInstanceId, StringComparer.Ordinal)
+                .ToDictionary(g => g.Key, g => g.First().DriverType, StringComparer.Ordinal);
+            var tagConfigWarnings = new List<(string TagId, string Text)>();
+            foreach (var t in draft.Tags.Where(t => t.EquipmentId is not null))
+            {
+                if (!driverTypeById.TryGetValue(t.DriverInstanceId, out var driverType)) continue;
+                foreach (var w in EquipmentTagConfigInspector.Inspect(driverType, t.TagConfig))
+                    tagConfigWarnings.Add((t.TagId, $"tag '{t.TagId}' (equipment '{t.EquipmentId}'): {w}"));
+            }
+            if (tagConfigWarnings.Count > 0)
+            {
+                if (_tagConfigValidationMode == TagConfigValidationMode.Error)
+                    errors.AddRange(tagConfigWarnings.Select(x => new ValidationError("TagConfigInvalid", x.Text, x.TagId)));
+                else
+                    foreach (var x in tagConfigWarnings)
+                        _log.Warning("StartDeployment: TagConfig warning (Warn mode, non-blocking): {Warning}", x.Text);
+            }
+
             if (errors.Count > 0)
             {
                 var summary = string.Join("; ", errors.Select(e => $"[{e.Code}] {e.Message}"));
@@ -277,11 +308,18 @@ public sealed class AdminOperationsActor : ReceiveActor
 
             _coordinator.Tell(new DispatchDeployment(deploymentId, revHash, msg.CorrelationId));
 
+            // Accepted message = the compile-cost advisory (if any) + any Warn-mode TagConfig warnings, so
+            // the operator sees the non-blocking strictness findings on a successful deploy.
+            var messageParts = new List<string>();
+            if (advisory is not null) messageParts.Add(advisory);
+            messageParts.AddRange(tagConfigWarnings.Select(x => x.Text));
+            var acceptedMessage = messageParts.Count > 0 ? string.Join("; ", messageParts) : null;
+
             replyTo.Tell(new StartDeploymentResult(
                 StartDeploymentOutcome.Accepted,
                 deploymentId,
                 revHash,
-                Message: advisory,
+                Message: acceptedMessage,
                 msg.CorrelationId));
         }
         catch (Exception ex)

src/Server/ZB.MOM.WW.OtOpcUa.ControlPlane/AdminOperations/EquipmentTagConfigInspector.cs

@@ -0,0 +1,47 @@
+using ZB.MOM.WW.OtOpcUa.Driver.AbCip;
+using ZB.MOM.WW.OtOpcUa.Driver.AbLegacy;
+using ZB.MOM.WW.OtOpcUa.Driver.FOCAS;
+using ZB.MOM.WW.OtOpcUa.Driver.Modbus;
+using ZB.MOM.WW.OtOpcUa.Driver.S7;
+using ZB.MOM.WW.OtOpcUa.Driver.TwinCAT;
+
+namespace ZB.MOM.WW.OtOpcUa.ControlPlane.AdminOperations;
+
+/// <summary>
+///     Deploy-time TagConfig inspection dispatched by <c>DriverType</c> (R2-11, 05/CONV-2). Mirrors the
+///     AdminUI <c>TagConfigValidator</c> shape: a case-insensitive map from the canonical driver-type string
+///     to that driver's lightweight <c>Contracts</c> parser <c>Inspect()</c>, returning human-readable
+///     warnings (present-but-invalid enum values that the lenient runtime silently defaults, plus
+///     structurally-unparseable TagConfig). Unmapped drivers (Galaxy, OpcUaClient) are skipped exactly as in
+///     the AdminUI validator. Never throws.
+/// </summary>
+public static class EquipmentTagConfigInspector
+{
+    private static readonly IReadOnlyDictionary<string, Func<string, IReadOnlyList<string>>> Inspectors =
+        new Dictionary<string, Func<string, IReadOnlyList<string>>>(StringComparer.OrdinalIgnoreCase)
+        {
+            ["Modbus"]   = ModbusEquipmentTagParser.Inspect,
+            ["S7"]       = S7EquipmentTagParser.Inspect,
+            ["AbCip"]    = AbCipEquipmentTagParser.Inspect,
+            ["AbLegacy"] = AbLegacyEquipmentTagParser.Inspect,
+            ["TwinCat"]  = TwinCATEquipmentTagParser.Inspect,
+            ["Focas"]    = FocasEquipmentTagParser.Inspect,
+        };
+
+    /// <summary>Inspects a tag's <c>TagConfig</c> for the given driver type. Returns the driver's warnings,
+    /// or an empty list when the driver type is unmapped (Galaxy/OpcUaClient) or the inputs are null.</summary>
+    /// <param name="driverType">The bound driver's <c>DriverType</c> (canonical string, case-insensitive).</param>
+    /// <param name="tagConfig">The equipment tag's <c>TagConfig</c> JSON.</param>
+    /// <returns>The warnings; empty when the driver is unmapped or clean.</returns>
+    public static IReadOnlyList<string> Inspect(string? driverType, string? tagConfig)
+    {
+        if (string.IsNullOrEmpty(driverType) || tagConfig is null) return Array.Empty<string>();
+        return Inspectors.TryGetValue(driverType, out var inspect) ? inspect(tagConfig) : Array.Empty<string>();
+    }
+
+    /// <summary>Whether the given driver type has a mapped inspector (equipment-tag protocol drivers only).</summary>
+    /// <param name="driverType">The bound driver's <c>DriverType</c>.</param>
+    /// <returns><see langword="true"/> when an inspector is registered for the driver type.</returns>
+    public static bool IsMapped(string? driverType) =>
+        !string.IsNullOrEmpty(driverType) && Inspectors.ContainsKey(driverType);
+}

src/Server/ZB.MOM.WW.OtOpcUa.ControlPlane/AdminOperations/TagConfigValidationMode.cs

@@ -0,0 +1,18 @@
+namespace ZB.MOM.WW.OtOpcUa.ControlPlane.AdminOperations;
+
+/// <summary>
+///     How the deploy gate treats TagConfig strictness inspection results (R2-11, 05/CONV-2). Sourced from
+///     <c>Deployment:TagConfigValidationMode</c> in appsettings; defaults to <see cref="Warn"/> so existing
+///     deployments are never blocked by a previously-tolerated typo.
+/// </summary>
+public enum TagConfigValidationMode
+{
+    /// <summary>Non-blocking: inspection warnings are logged and appended to the accepted
+    /// <c>StartDeploymentResult.Message</c>, but the deploy still succeeds. The default.</summary>
+    Warn,
+
+    /// <summary>Blocking: inspection warnings fold into the draft-gate reject list, so a config with a
+    /// typo'd enum (or unparseable TagConfig) cannot be re-deployed until fixed. Opt-in per environment
+    /// once the fleet deploys warning-clean.</summary>
+    Error,
+}

src/Server/ZB.MOM.WW.OtOpcUa.ControlPlane/ServiceCollectionExtensions.cs

@@ -2,6 +2,7 @@ using Akka.Actor;
 using Akka.Cluster.Hosting;
 using Akka.Hosting;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using ZB.MOM.WW.OtOpcUa.Configuration;
 using ZB.MOM.WW.OtOpcUa.ControlPlane.AdminOperations;
@@ -61,7 +62,12 @@ public static class ServiceCollectionExtensions
                 var dbFactory = resolver.GetService<IDbContextFactory<OtOpcUaConfigDbContext>>();
                 var coordinator = registry.Get<ConfigPublishCoordinatorKey>();
                 var probes = resolver.GetService<IEnumerable<IDriverProbe>>() ?? Enumerable.Empty<IDriverProbe>();
-                return AdminOperationsActor.Props(dbFactory, coordinator, probes);
+                // R2-11 (05/CONV-2): deploy-gate TagConfig strictness mode from appsettings
+                // (Deployment:TagConfigValidationMode = Warn default | Error opt-in).
+                var mode = Enum.TryParse<TagConfigValidationMode>(
+                    resolver.GetService<IConfiguration>()?["Deployment:TagConfigValidationMode"],
+                    ignoreCase: true, out var m) ? m : TagConfigValidationMode.Warn;
+                return AdminOperationsActor.Props(dbFactory, coordinator, probes, mode);
             },
             singletonOptions);
 

src/Server/ZB.MOM.WW.OtOpcUa.ControlPlane/ZB.MOM.WW.OtOpcUa.ControlPlane.csproj

@@ -26,6 +26,14 @@
         <!-- Roslyn-free; gives HandleStartDeploymentAsync PassthroughScript.TryMatch to exclude
              mirror scripts (which compile to ~nothing) from the deploy compile-cost advisory. -->
         <ProjectReference Include="..\..\Core\ZB.MOM.WW.OtOpcUa.Core.Scripting.Abstractions\ZB.MOM.WW.OtOpcUa.Core.Scripting.Abstractions.csproj"/>
+        <!-- R2-11 (05/CONV-2): the driver-typed EquipmentTagConfigInspector dispatches to each driver's
+             lightweight Contracts parser Inspect(), the same dependency-light consumption AdminUI does. -->
+        <ProjectReference Include="..\..\Drivers\ZB.MOM.WW.OtOpcUa.Driver.Modbus.Contracts\ZB.MOM.WW.OtOpcUa.Driver.Modbus.Contracts.csproj"/>
+        <ProjectReference Include="..\..\Drivers\ZB.MOM.WW.OtOpcUa.Driver.S7.Contracts\ZB.MOM.WW.OtOpcUa.Driver.S7.Contracts.csproj"/>
+        <ProjectReference Include="..\..\Drivers\ZB.MOM.WW.OtOpcUa.Driver.AbCip.Contracts\ZB.MOM.WW.OtOpcUa.Driver.AbCip.Contracts.csproj"/>
+        <ProjectReference Include="..\..\Drivers\ZB.MOM.WW.OtOpcUa.Driver.AbLegacy.Contracts\ZB.MOM.WW.OtOpcUa.Driver.AbLegacy.Contracts.csproj"/>
+        <ProjectReference Include="..\..\Drivers\ZB.MOM.WW.OtOpcUa.Driver.TwinCAT.Contracts\ZB.MOM.WW.OtOpcUa.Driver.TwinCAT.Contracts.csproj"/>
+        <ProjectReference Include="..\..\Drivers\ZB.MOM.WW.OtOpcUa.Driver.FOCAS.Contracts\ZB.MOM.WW.OtOpcUa.Driver.FOCAS.Contracts.csproj"/>
     </ItemGroup>
 
 </Project>

src/Server/ZB.MOM.WW.OtOpcUa.Host/appsettings.json

@@ -43,5 +43,9 @@
     "DrainIntervalSeconds": 5,
     "Capacity": 1000000,
     "DeadLetterRetentionDays": 30
+  },
+  "Deployment": {
+    "_comment": "R2-11 (05/CONV-2): deploy-gate TagConfig strictness. Warn (default) = non-blocking warnings logged + appended to the deployment result message; Error = a config with a typo'd enum or unparseable TagConfig is rejected at the draft gate. Running servers are untouched; the gate only sees re-deploys.",
+    "TagConfigValidationMode": "Warn"
   }
 }

src/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer/AddressSpaceApplier.cs

@@ -689,7 +689,7 @@ public sealed class AddressSpaceApplier
     // REACH (live-verified): the shape path only fires for drivers whose TagConfig carries a stable
     // top-level "FullName" (Galaxy = tag_name.AttributeName; OpcUaClient = the node id) — there a DataType/array
     // edit leaves FullName untouched ⇒ surgical. For structured-TagConfig protocol drivers (Modbus/S7/AbCip/…)
-    // AddressSpaceComposer.ExtractTagFullName falls back to the RAW TagConfig blob as FullName, so a DataType/
+    // TagConfigIntent.Parse falls back to the RAW TagConfig blob as FullName, so a DataType/
     // array edit also mutates that blob ⇒ FullName differs ⇒ this returns false ⇒ full rebuild. That is the
     // correct safe default (a protocol driver's subscription needs re-spawning for a new shape anyway).
     private static bool TagDeltaIsSurgicalEligible(AddressSpacePlan.EquipmentTagDelta d) =>

src/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer/AddressSpaceComposer.cs

@@ -1,5 +1,4 @@
 using System.Diagnostics;
-using System.Text.Json;
 using ZB.MOM.WW.OtOpcUa.Commons.Types;
 using ZB.MOM.WW.OtOpcUa.Configuration.Entities;
 using ZB.MOM.WW.OtOpcUa.Configuration.Enums;
@@ -66,11 +65,11 @@ public sealed record UnsLineProjection(string UnsLineId, string UnsAreaId, strin
 /// (both <c>null</c> ⇒ driver-less / no device), copied straight from the <c>Equipment</c> row.
 /// <see cref="DeviceHost"/> is the device's connection host (e.g. <c>"10.0.0.5:8193"</c>) resolved from the
 /// bound <c>Device</c>'s schemaless <c>DeviceConfig</c> JSON via
-/// <see cref="AddressSpaceComposer.TryExtractDeviceHost"/> — <c>null</c> when there is no device, no
-/// <c>HostAddress</c> in its config, or the host cannot be parsed. These three let a later task graft a
-/// driver's discovered FixedTree onto an equipment that has zero authored tags, and partition a
+/// <see cref="ZB.MOM.WW.OtOpcUa.Commons.Types.DeviceConfigIntent.TryExtractHost"/> — <c>null</c> when there
+/// is no device, no <c>HostAddress</c> in its config, or the host cannot be parsed. These three let a later
+/// task graft a driver's discovered FixedTree onto an equipment that has zero authored tags, and partition a
 /// multi-device driver by host. The value is normalized identically on both the live-edit composer and
-/// the artifact-decode sides (single source of truth: <see cref="AddressSpaceComposer.TryExtractDeviceHost"/>);
+/// the artifact-decode sides (single source of truth: <see cref="ZB.MOM.WW.OtOpcUa.Commons.Types.DeviceConfigIntent"/>);
 /// the later partition task MUST normalize the driver-discovered device-host folder segment the same way
 /// (trim + lower-case) so the two compare equal.</para>
 /// <para><b>Address-space-rebuild interaction (accepted trade-off).</b> These three fields participate in
@@ -350,8 +349,8 @@ public static class AddressSpaceComposer
         var resolvedScripts = scripts ?? Array.Empty<Script>();
 
         // DeviceId → connection host, resolved once from each bound Device's schemaless DeviceConfig JSON
-        // via the shared TryExtractDeviceHost (single source of truth + normalization for both this
-        // composer and the artifact-decode mirror in DeploymentArtifact, so EquipmentNode.DeviceHost is
+        // via the shared DeviceConfigIntent.TryExtractHost (single source of truth + normalization for both
+        // this composer and the artifact-decode mirror in DeploymentArtifact, so EquipmentNode.DeviceHost is
         // byte-parity-equal). This MUST match DeploymentArtifact.BuildDeviceHostMap semantics EXACTLY:
         // Ordinal comparer, skip blank/whitespace DeviceIds, and LAST-WINS on a duplicate DeviceId (a
         // foreach assignment, NOT ToDictionary which would THROW on a dupe — diverging from the decode
@@ -360,7 +359,7 @@ public static class AddressSpaceComposer
         foreach (var d in devices ?? Array.Empty<Device>())
         {
             if (string.IsNullOrWhiteSpace(d.DeviceId)) continue;
-            deviceHostById[d.DeviceId] = TryExtractDeviceHost(d.DeviceConfig);
+            deviceHostById[d.DeviceId] = DeviceConfigIntent.TryExtractHost(d.DeviceConfig);
         }
         var areas = unsAreas
             .OrderBy(a => a.UnsAreaId, StringComparer.Ordinal)
@@ -415,8 +414,11 @@ public static class AddressSpaceComposer
             .ThenBy(t => t.Name, StringComparer.Ordinal)
             .Select(t =>
             {
-                var (isHistorized, historianTagname) = ExtractTagHistorize(t.TagConfig);
-                var (isArray, arrayLength) = ExtractTagArray(t.TagConfig);
+                // Parse the schemaless TagConfig blob ONCE per tag (01/P-1) via the shared byte-parity
+                // authority (01/C-1). TagConfigIntent.Parse is the SINGLE SOURCE OF TRUTH the
+                // artifact-decode seam (DeploymentArtifact), the draft gate (DraftValidator), and the
+                // walker all consume — so the live-compose and artifact-decode plans stay byte-equal.
+                var intent = TagConfigIntent.Parse(t.TagConfig);
                 return new EquipmentTagPlan(
                     TagId: t.TagId,
                     EquipmentId: t.EquipmentId!,
@@ -424,13 +426,13 @@ public static class AddressSpaceComposer
                     FolderPath: t.FolderPath ?? string.Empty,
                     Name: t.Name,
                     DataType: t.DataType,
-                    FullName: ExtractTagFullName(t.TagConfig),
+                    FullName: intent.FullName,
                     Writable: t.AccessLevel == TagAccessLevel.ReadWrite,
-                    Alarm: ExtractTagAlarm(t.TagConfig),
-                    IsHistorized: isHistorized,
-                    HistorianTagname: historianTagname,
-                    IsArray: isArray,
-                    ArrayLength: arrayLength);
+                    Alarm: intent.Alarm is { } a ? new EquipmentTagAlarmInfo(a.AlarmType, a.Severity, a.HistorizeToAveva) : null,
+                    IsHistorized: intent.IsHistorized,
+                    HistorianTagname: intent.HistorianTagname,
+                    IsArray: intent.IsArray,
+                    ArrayLength: intent.ArrayLength);
             })
             .ToList();
 
@@ -523,165 +525,4 @@ public static class AddressSpaceComposer
         };
     }
 
-    /// <summary>
-    ///     Extract the driver-side full reference from a <see cref="Tag.TagConfig"/> JSON blob: the
-    ///     <c>CK_Tag_TagConfig_IsJson</c> constraint guarantees a JSON object, and every shipped
-    ///     driver stores the wire-level address in a top-level <c>FullName</c> field. Replicated from
-    ///     <c>EquipmentNodeWalker.ExtractFullName</c> because OpcUaServer does not reference the Core
-    ///     driver assembly (kept in sync with the artifact-decode copy in <c>DeploymentArtifact</c>).
-    ///     Falls back to the raw blob when it is not a JSON object with a string <c>FullName</c>.
-    /// </summary>
-    /// <param name="tagConfig">The tag's wire-level address JSON.</param>
-    /// <returns>The extracted full reference, or the raw blob when no <c>FullName</c> is present.</returns>
-    private static string ExtractTagFullName(string tagConfig)
-    {
-        if (string.IsNullOrWhiteSpace(tagConfig)) return tagConfig;
-        try
-        {
-            using var doc = JsonDocument.Parse(tagConfig);
-            if (doc.RootElement.ValueKind == JsonValueKind.Object
-                && doc.RootElement.TryGetProperty("FullName", out var fullName)
-                && fullName.ValueKind == JsonValueKind.String)
-            {
-                return fullName.GetString() ?? tagConfig;
-            }
-        }
-        catch (JsonException) { /* fall through to raw blob */ }
-        return tagConfig;
-    }
-
-    /// <summary>
-    ///     Extract a <see cref="Device"/>'s connection host from its schemaless <c>DeviceConfig</c> JSON:
-    ///     the top-level <c>"HostAddress"</c> string (e.g. <c>"10.201.31.5:8193"</c>) — the same value a
-    ///     FOCAS driver emits as its discovered device-host folder segment. Returns <c>null</c> when the
-    ///     config is blank, not a JSON object, has no string <c>HostAddress</c>, or the value is
-    ///     blank/whitespace. Never throws.
-    ///     <para>The returned host is deterministically normalized — trimmed and lower-cased — so the
-    ///     live-edit composer side and the artifact-decode side (<c>DeploymentArtifact</c>) agree
-    ///     byte-for-byte. This method is the SINGLE SOURCE OF TRUTH for that normalization: the later
-    ///     FixedTree-partition task MUST normalize the driver-discovered device-host folder segment the
-    ///     same way (call this, or apply the identical trim + lower-case) before comparing the two.</para>
-    /// </summary>
-    /// <param name="deviceConfigJson">The device's schemaless <c>DeviceConfig</c> JSON blob.</param>
-    /// <returns>The normalized device host, or <c>null</c> when absent/blank/unparseable.</returns>
-    public static string? TryExtractDeviceHost(string? deviceConfigJson)
-    {
-        if (string.IsNullOrWhiteSpace(deviceConfigJson)) return null;
-        try
-        {
-            using var doc = JsonDocument.Parse(deviceConfigJson);
-            if (doc.RootElement.ValueKind != JsonValueKind.Object) return null;
-            if (!doc.RootElement.TryGetProperty("HostAddress", out var hostEl)
-                || hostEl.ValueKind != JsonValueKind.String) return null;
-            var raw = hostEl.GetString();
-            if (string.IsNullOrWhiteSpace(raw)) return null;
-            // Deterministic normalization (trim + lower-case) so both seams produce the identical string.
-            return NormalizeDeviceHost(raw);
-        }
-        catch (JsonException) { return null; }
-    }
-
-    /// <summary>
-    ///     The SINGLE SOURCE OF TRUTH for device-host normalization: trims surrounding whitespace and
-    ///     lower-cases (invariant). <see cref="TryExtractDeviceHost"/> applies this to a <c>Device</c>'s
-    ///     parsed <c>HostAddress</c>, and the FixedTree-partition path (<c>DriverHostActor</c>) applies the
-    ///     SAME function to a driver-discovered device-host folder segment before comparing the two — so an
-    ///     <see cref="EquipmentNode.DeviceHost"/> and a captured folder segment for the same device compare
-    ///     equal regardless of case/whitespace. Idempotent (a value already normalized is unchanged).
-    /// </summary>
-    /// <param name="host">The raw host string (non-null; a non-empty <c>HostAddress</c> or folder segment).</param>
-    /// <returns>The normalized host (trimmed + lower-cased).</returns>
-    public static string NormalizeDeviceHost(string host) => host.Trim().ToLowerInvariant();
-
-    /// <summary>Parses the optional <c>alarm</c> object from a tag's <c>TagConfig</c> JSON. Returns null
-    /// when absent, non-object, or non-JSON (the tag is then a plain variable). Never throws. The
-    /// artifact-decode side (<c>DeploymentArtifact.ExtractTagAlarm</c>) MUST parse identically (byte-parity).</summary>
-    /// <param name="tagConfig">The tag's raw <c>TagConfig</c> JSON (nullable/blank tolerated).</param>
-    /// <returns>The parsed native-alarm intent, or <see langword="null"/> when the tag has no alarm object.</returns>
-    internal static EquipmentTagAlarmInfo? ExtractTagAlarm(string? tagConfig)
-    {
-        if (string.IsNullOrWhiteSpace(tagConfig)) return null;
-        try
-        {
-            using var doc = JsonDocument.Parse(tagConfig);
-            if (doc.RootElement.ValueKind != JsonValueKind.Object) return null;
-            if (!doc.RootElement.TryGetProperty("alarm", out var a) || a.ValueKind != JsonValueKind.Object) return null;
-            var type = a.TryGetProperty("alarmType", out var tEl) && tEl.ValueKind == JsonValueKind.String
-                ? (tEl.GetString() ?? "AlarmCondition") : "AlarmCondition";
-            var sev = a.TryGetProperty("severity", out var sEl) && sEl.ValueKind == JsonValueKind.Number
-                && sEl.TryGetInt32(out var sv) ? sv : 500;
-            // historizeToAveva (bool?, absent ⇒ null ⇒ historize): only an explicit false suppresses the
-            // durable AVEVA write at the HistorianAdapterActor gate; a non-bool node ⇒ null (default-on).
-            bool? historize = a.TryGetProperty("historizeToAveva", out var hEl)
-                    && hEl.ValueKind is JsonValueKind.True or JsonValueKind.False
-                ? hEl.GetBoolean()
-                : null;
-            return new EquipmentTagAlarmInfo(type, sev, historize);
-        }
-        catch (JsonException) { return null; }
-    }
-
-    /// <summary>Parses the optional server-side HistoryRead intent from a tag's <c>TagConfig</c> JSON:
-    /// the <c>isHistorized</c> bool (absent / not a bool / non-object root / blank / malformed ⇒
-    /// <c>false</c>) and the optional <c>historianTagname</c> string override (absent / not a string /
-    /// whitespace-or-empty ⇒ <c>null</c>, meaning the historian tagname defaults to the tag's FullName,
-    /// resolved later). The raw string value is used — not trimmed — matching <c>ExtractTagFullName</c> /
-    /// <c>ExtractTagAlarm</c>. Never throws. The artifact-decode side
-    /// (<c>DeploymentArtifact.ExtractTagHistorize</c>) MUST parse identically (byte-parity).</summary>
-    /// <param name="tagConfig">The tag's raw <c>TagConfig</c> JSON (nullable/blank tolerated).</param>
-    /// <returns>The parsed historize flag and optional historian tagname override.</returns>
-    internal static (bool IsHistorized, string? HistorianTagname) ExtractTagHistorize(string? tagConfig)
-    {
-        if (string.IsNullOrWhiteSpace(tagConfig)) return (false, null);
-        try
-        {
-            using var doc = JsonDocument.Parse(tagConfig);
-            if (doc.RootElement.ValueKind != JsonValueKind.Object) return (false, null);
-            var isHistorized = doc.RootElement.TryGetProperty("isHistorized", out var hEl)
-                && (hEl.ValueKind == JsonValueKind.True || hEl.ValueKind == JsonValueKind.False)
-                && hEl.GetBoolean();
-            string? tagname = null;
-            if (doc.RootElement.TryGetProperty("historianTagname", out var nEl)
-                && nEl.ValueKind == JsonValueKind.String)
-            {
-                var raw = nEl.GetString();
-                if (!string.IsNullOrWhiteSpace(raw)) tagname = raw;
-            }
-            return (isHistorized, tagname);
-        }
-        catch (JsonException) { return (false, null); }
-    }
-
-    /// <summary>Parses the optional array intent from a tag's <c>TagConfig</c> JSON: the <c>isArray</c>
-    /// bool (absent / not a bool / non-object root / blank / malformed ⇒ <c>false</c>) and the optional
-    /// <c>arrayLength</c> uint. The length is honoured ONLY when <c>isArray</c> is true AND the prop is a
-    /// JSON number that fits <c>uint</c> (else <c>null</c> ⇒ unbounded 1-D array,
-    /// <c>ArrayDimensions=[0]</c> at materialisation). Mirrors
-    /// <see cref="ExtractTagHistorize"/> exactly in structure + null/blank/non-object/malformed-JSON
-    /// tolerance. Never throws. The artifact-decode side
-    /// (<c>DeploymentArtifact.ExtractTagArray</c>) MUST parse identically (byte-parity).</summary>
-    /// <param name="tagConfig">The tag's raw <c>TagConfig</c> JSON (nullable/blank tolerated).</param>
-    /// <returns>The parsed array flag and optional array length.</returns>
-    internal static (bool IsArray, uint? ArrayLength) ExtractTagArray(string? tagConfig)
-    {
-        if (string.IsNullOrWhiteSpace(tagConfig)) return (false, null);
-        try
-        {
-            using var doc = JsonDocument.Parse(tagConfig);
-            if (doc.RootElement.ValueKind != JsonValueKind.Object) return (false, null);
-            var isArray = doc.RootElement.TryGetProperty("isArray", out var aEl)
-                && (aEl.ValueKind == JsonValueKind.True || aEl.ValueKind == JsonValueKind.False)
-                && aEl.GetBoolean();
-            uint? arrayLength = null;
-            if (isArray
-                && doc.RootElement.TryGetProperty("arrayLength", out var lEl)
-                && lEl.ValueKind == JsonValueKind.Number
-                && lEl.TryGetUInt32(out var len))
-            {
-                arrayLength = len;
-            }
-            return (isArray, arrayLength);
-        }
-        catch (JsonException) { return (false, null); }
-    }
 }

src/Server/ZB.MOM.WW.OtOpcUa.Runtime/Drivers/DeploymentArtifact.cs

@@ -458,8 +458,10 @@ public static class DeploymentArtifact
             // ordinary equipment tags now (GalaxyMxGateway is a standard Equipment-kind driver).
             if (!equipmentNamespaces.Contains(nsId)) continue;
 
-            var (isHistorized, historianTagname) = ExtractTagHistorize(tagConfig);
-            var (isArray, arrayLength) = ExtractTagArray(tagConfig);
+            // Parse the schemaless TagConfig blob ONCE per tag via the shared byte-parity authority
+            // (01/C-1) — the SAME TagConfigIntent.Parse the live-compose seam (AddressSpaceComposer)
+            // consumes, so the artifact-decode plan stays byte-equal with the composer's.
+            var intent = TagConfigIntent.Parse(tagConfig);
             result.Add(new EquipmentTagPlan(
                 TagId: tagId!,
                 EquipmentId: equipmentId!,
@@ -467,13 +469,13 @@ public static class DeploymentArtifact
                 FolderPath: folder ?? string.Empty,
                 Name: name!,
                 DataType: dataType ?? "BaseDataType",
-                FullName: ExtractTagFullName(tagConfig),
+                FullName: intent.FullName,
                 Writable: writable,
-                Alarm: ExtractTagAlarm(tagConfig),
-                IsHistorized: isHistorized,
-                HistorianTagname: historianTagname,
-                IsArray: isArray,
-                ArrayLength: arrayLength));
+                Alarm: intent.Alarm is { } a ? new EquipmentTagAlarmInfo(a.AlarmType, a.Severity, a.HistorizeToAveva) : null,
+                IsHistorized: intent.IsHistorized,
+                HistorianTagname: intent.HistorianTagname,
+                IsArray: intent.IsArray,
+                ArrayLength: intent.ArrayLength));
         }
 
         result.Sort((a, b) =>
@@ -665,113 +667,6 @@ public static class DeploymentArtifact
         return result;
     }
 
-    /// <summary>
-    ///     Extract the driver-side full reference from a tag's TagConfig JSON (top-level "FullName"
-    ///     field). The artifact-decode mirror of <c>AddressSpaceComposer.ExtractTagFullName</c> /
-    ///     <c>EquipmentNodeWalker.ExtractFullName</c> — replicated because Runtime does not reference
-    ///     the Core driver assembly. Falls back to the raw blob when absent or non-JSON.
-    /// </summary>
-    private static string ExtractTagFullName(string? tagConfig)
-    {
-        if (string.IsNullOrWhiteSpace(tagConfig)) return tagConfig ?? string.Empty;
-        try
-        {
-            using var doc = JsonDocument.Parse(tagConfig);
-            if (doc.RootElement.ValueKind == JsonValueKind.Object
-                && doc.RootElement.TryGetProperty("FullName", out var fullName)
-                && fullName.ValueKind == JsonValueKind.String)
-            {
-                return fullName.GetString() ?? tagConfig;
-            }
-        }
-        catch (JsonException) { /* fall through to raw blob */ }
-        return tagConfig;
-    }
-
-    /// <summary>Parses the optional <c>alarm</c> object from a tag's <c>TagConfig</c> JSON. Returns null
-    /// when absent, non-object, or non-JSON (the tag is then a plain variable). Never throws. The
-    /// live-edit side (<c>AddressSpaceComposer.ExtractTagAlarm</c>) MUST parse identically (byte-parity).</summary>
-    private static EquipmentTagAlarmInfo? ExtractTagAlarm(string? tagConfig)
-    {
-        if (string.IsNullOrWhiteSpace(tagConfig)) return null;
-        try
-        {
-            using var doc = JsonDocument.Parse(tagConfig);
-            if (doc.RootElement.ValueKind != JsonValueKind.Object) return null;
-            if (!doc.RootElement.TryGetProperty("alarm", out var a) || a.ValueKind != JsonValueKind.Object) return null;
-            var type = a.TryGetProperty("alarmType", out var tEl) && tEl.ValueKind == JsonValueKind.String
-                ? (tEl.GetString() ?? "AlarmCondition") : "AlarmCondition";
-            var sev = a.TryGetProperty("severity", out var sEl) && sEl.ValueKind == JsonValueKind.Number
-                && sEl.TryGetInt32(out var sv) ? sv : 500;
-            // historizeToAveva (bool?, absent ⇒ null ⇒ historize): byte-parity with
-            // AddressSpaceComposer.ExtractTagAlarm — only an explicit false suppresses the durable AVEVA write.
-            bool? historize = a.TryGetProperty("historizeToAveva", out var hEl)
-                    && hEl.ValueKind is JsonValueKind.True or JsonValueKind.False
-                ? hEl.GetBoolean()
-                : null;
-            return new EquipmentTagAlarmInfo(type, sev, historize);
-        }
-        catch (JsonException) { return null; }
-    }
-
-    /// <summary>Parses the optional server-side HistoryRead intent from a tag's <c>TagConfig</c> JSON:
-    /// the <c>isHistorized</c> bool (absent / not a bool / non-object root / blank / malformed ⇒
-    /// <c>false</c>) and the optional <c>historianTagname</c> string override (absent / not a string /
-    /// whitespace-or-empty ⇒ <c>null</c>, meaning the historian tagname defaults to the tag's FullName,
-    /// resolved later). The raw string value is used — not trimmed — matching <c>ExtractTagFullName</c> /
-    /// <c>ExtractTagAlarm</c>. Never throws. The live-edit composer side
-    /// (<c>AddressSpaceComposer.ExtractTagHistorize</c>) MUST parse identically (byte-parity).</summary>
-    private static (bool IsHistorized, string? HistorianTagname) ExtractTagHistorize(string? tagConfig)
-    {
-        if (string.IsNullOrWhiteSpace(tagConfig)) return (false, null);
-        try
-        {
-            using var doc = JsonDocument.Parse(tagConfig);
-            if (doc.RootElement.ValueKind != JsonValueKind.Object) return (false, null);
-            var isHistorized = doc.RootElement.TryGetProperty("isHistorized", out var hEl)
-                && (hEl.ValueKind == JsonValueKind.True || hEl.ValueKind == JsonValueKind.False)
-                && hEl.GetBoolean();
-            string? tagname = null;
-            if (doc.RootElement.TryGetProperty("historianTagname", out var nEl)
-                && nEl.ValueKind == JsonValueKind.String)
-            {
-                var raw = nEl.GetString();
-                if (!string.IsNullOrWhiteSpace(raw)) tagname = raw;
-            }
-            return (isHistorized, tagname);
-        }
-        catch (JsonException) { return (false, null); }
-    }
-
-    /// <summary>Parses the optional array intent from a tag's <c>TagConfig</c> JSON: the <c>isArray</c>
-    /// bool (absent / not a bool / non-object root / blank / malformed ⇒ <c>false</c>) and the optional
-    /// <c>arrayLength</c> uint (honoured ONLY when <c>isArray</c> is true AND the prop is a JSON number
-    /// that fits <c>uint</c>; else <c>null</c>). Mirrors <see cref="ExtractTagHistorize"/> in structure +
-    /// null/blank/non-object/malformed-JSON tolerance. Never throws. The live-edit composer side
-    /// (<c>AddressSpaceComposer.ExtractTagArray</c>) MUST parse identically (byte-parity).</summary>
-    private static (bool IsArray, uint? ArrayLength) ExtractTagArray(string? tagConfig)
-    {
-        if (string.IsNullOrWhiteSpace(tagConfig)) return (false, null);
-        try
-        {
-            using var doc = JsonDocument.Parse(tagConfig);
-            if (doc.RootElement.ValueKind != JsonValueKind.Object) return (false, null);
-            var isArray = doc.RootElement.TryGetProperty("isArray", out var aEl)
-                && (aEl.ValueKind == JsonValueKind.True || aEl.ValueKind == JsonValueKind.False)
-                && aEl.GetBoolean();
-            uint? arrayLength = null;
-            if (isArray
-                && doc.RootElement.TryGetProperty("arrayLength", out var lEl)
-                && lEl.ValueKind == JsonValueKind.Number
-                && lEl.TryGetUInt32(out var len))
-            {
-                arrayLength = len;
-            }
-            return (isArray, arrayLength);
-        }
-        catch (JsonException) { return (false, null); }
-    }
-
     private static IReadOnlyList<T> ReadArray<T>(JsonElement root, string propertyName, Func<JsonElement, T?> reader)
         where T : class
     {
@@ -819,7 +714,7 @@ public static class DeploymentArtifact
 
     /// <summary>Build the <c>DeviceId</c> → connection-host map from the artifact's <c>Devices</c> array
     /// (each row carries a <c>DeviceId</c> + schemaless <c>DeviceConfig</c> JSON). The host is resolved via
-    /// the shared <see cref="AddressSpaceComposer.TryExtractDeviceHost"/> so the artifact-decode side
+    /// the shared <see cref="DeviceConfigIntent.TryExtractHost"/> so the artifact-decode side
     /// normalizes byte-identically to the live-edit composer. Ordinal comparer + last-wins on a duplicate
     /// DeviceId. A missing/empty/non-array <c>Devices</c> property yields an empty map (no device hosts).</summary>
     /// <param name="root">The artifact root element.</param>
@@ -834,7 +729,7 @@ public static class DeploymentArtifact
             if (el.ValueKind != JsonValueKind.Object) continue;
             var deviceId = ReadString(el, "DeviceId");
             if (string.IsNullOrWhiteSpace(deviceId)) continue;
-            map[deviceId!] = AddressSpaceComposer.TryExtractDeviceHost(ReadString(el, "DeviceConfig"));
+            map[deviceId!] = DeviceConfigIntent.TryExtractHost(ReadString(el, "DeviceConfig"));
         }
         return map;
     }

src/Server/ZB.MOM.WW.OtOpcUa.Runtime/Drivers/DriverHostActor.cs

@@ -728,7 +728,7 @@ public sealed class DriverHostActor : ReceiveActor, IWithTimers
     ///         host folder) is warn-skipped — its nodes are NOT mis-grafted; the matched partitions still graft.</item>
     ///     </list>
     ///     The device-host folder segment AND the stored DeviceHost are both run through the SAME
-    ///     <see cref="AddressSpaceComposer.NormalizeDeviceHost"/> (single source of truth), so they compare equal
+    ///     <see cref="DeviceConfigIntent.NormalizeHost"/> (single source of truth), so they compare equal
     ///     regardless of case/whitespace.
     ///     <para><b>Warn-spam taming.</b> The unmatched/ambiguous/degenerate condition is warned ONCE then
     ///     Debug-logged on the repeated re-discovery passes (see <see cref="ShouldWarnPartition"/>).</para>
@@ -755,7 +755,7 @@ public sealed class DriverHostActor : ReceiveActor, IWithTimers
             if (!candidateSet.Contains(node.EquipmentId) || node.DeviceHost is null) continue;
             // DeviceHost is already normalized at compose/decode time; re-normalize through the shared helper so
             // the comparison is the single source of truth (idempotent — harmless if it was already normalized).
-            var host = AddressSpaceComposer.NormalizeDeviceHost(node.DeviceHost);
+            var host = DeviceConfigIntent.NormalizeHost(node.DeviceHost);
             if (ambiguousHosts.Contains(host)) continue;
             if (hostToEquipment.TryGetValue(host, out var existing))
             {
@@ -789,7 +789,7 @@ public sealed class DriverHostActor : ReceiveActor, IWithTimers
         foreach (var n in msg.Nodes)
         {
             var key = n.FolderPathSegments.Count >= 2
-                ? AddressSpaceComposer.NormalizeDeviceHost(n.FolderPathSegments[1])
+                ? DeviceConfigIntent.NormalizeHost(n.FolderPathSegments[1])
                 : null;
             if (key is not null && hostToEquipment.ContainsKey(key))
             {