Implement EnsureTagAsync (live-verified) + DeleteTagAsync (DelT semantics partial)

New SDK surface:
  HistorianClient.EnsureTagAsync(HistorianTagDefinition)
  HistorianClient.DeleteTagAsync(string tagName)

Plumbing:
  src/AVEVA.Historian.Client/Models/HistorianTagDefinition.cs
    Public input model — TagName/Description/EngineeringUnit/DataType/MinEU/MaxEU.
    Currently only HistorianDataType.Float is live-verified.

  src/AVEVA.Historian.Client/Wcf/HistorianTagWriteProtocol.cs
    SerializeAnalogCTagMetadata produces 146-byte payload byte-for-byte
    identical to the captured native EnsT2(Float) request.
    SerializeDeleteTagNames produces ushort 0x6751 + ushort 1 + uint count
    + per-tag (uint charCount + UTF-16 chars).

  src/AVEVA.Historian.Client/Wcf/HistorianWcfTagWriteOrchestrator.cs
    Both EnsT2 and DelT run the full Stat-priming chain captured for the
    analog flow (UpdC3 + Stat.GetV ×3 + Stat.GETHI ×2 + 7× GetSystemParameter
    + Trx.GetV + Retr.GetV).

  src/AVEVA.Historian.Client/Wcf/HistorianWcfTagClient.cs
    MapDataType extended to accept tag-origin marker 0xC7 (SDK-created tags).

Tests:
  5 golden-byte tests (HistorianTagWriteProtocolTests):
    SerializeAnalogCTagMetadata byte-for-byte match against captured 146-byte fixture
    SerializeAnalogCTagMetadata produces different bytes for different inputs
    SerializeDeleteTagNames single-tag matches captured shape
    SerializeDeleteTagNames multi-tag appends each
    SerializeDeleteTagNames empty list throws

  1 live integration test (gated by HISTORIAN_WRITE_SANDBOX_TAG):
    EnsureTagAsync_AndDeleteTagAsync_RoundTrip_AgainstLocalHistorian
    EnsureTagAsync creates the sandbox tag, GetTagMetadataAsync reads it
    back. 130/130 tests pass.

Harness improvements:
  --write-delete-after now runs DelT independently of AddStreamedValue
  outcome.
  HistorianTagStatusList constructed correctly for DeleteTags reflection
  call (previous StringCollection attempt failed with TypeMismatch).

Known DelT gap: SDK's DeleteTagAsync returns true but server-side
cascading deletion does not always complete (the row remains in
Runtime.dbo.Tag). The captured native flow's DelT removes the tag
cleanly (verified via harness --write-delete-after), so something
around the WCF DelT call is missing from our orchestrator. Documented
as known issue with SMC-based cleanup as workaround.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

tests/AVEVA.Historian.Client.Tests/HistorianClientIntegrationTests.cs

@@ -301,6 +301,62 @@ public sealed class HistorianClientIntegrationTests
         Assert.NotNull(metadata.Key);
     }
 
+    [Fact]
+    public async Task EnsureTagAsync_AndDeleteTagAsync_RoundTrip_AgainstLocalHistorian()
+    {
+        // Per docs/plans/write-commands-reverse-engineering.md safety rules: localhost only,
+        // sandbox tag name must start with "RetestSdkWrite", tag is created if missing and
+        // always deleted at the end so the test leaves zero residue.
+        string? host = Environment.GetEnvironmentVariable("HISTORIAN_HOST");
+        string? sandboxTag = Environment.GetEnvironmentVariable("HISTORIAN_WRITE_SANDBOX_TAG");
+        if (string.IsNullOrWhiteSpace(host) || !string.Equals(host, "localhost", StringComparison.OrdinalIgnoreCase) || !OperatingSystem.IsWindows())
+        {
+            return;
+        }
+        if (string.IsNullOrWhiteSpace(sandboxTag) || !sandboxTag.StartsWith("RetestSdkWrite", StringComparison.Ordinal))
+        {
+            return; // safety gate per the plan
+        }
+
+        HistorianClient client = new(new HistorianClientOptions
+        {
+            Host = host,
+            IntegratedSecurity = true,
+            Transport = HistorianTransport.LocalPipe
+        });
+
+        AVEVA.Historian.Client.Models.HistorianTagDefinition definition = new()
+        {
+            TagName = sandboxTag,
+            Description = "SDK live integration test sandbox",
+            EngineeringUnit = "test",
+            DataType = AVEVA.Historian.Client.Models.HistorianDataType.Float,
+            MinEU = 0.0,
+            MaxEU = 100.0,
+        };
+
+        try
+        {
+            // EnsureTags2 returns true on fresh creation, false on "already exists with same
+            // metadata" (per the captured event-flow analog). The success criterion is the
+            // tag being PRESENT in the DB after the call, not the return value.
+            _ = await client.EnsureTagAsync(definition, CancellationToken.None);
+
+            AVEVA.Historian.Client.Models.HistorianTagMetadata? metadata =
+                await client.GetTagMetadataAsync(sandboxTag, CancellationToken.None);
+            Assert.NotNull(metadata);
+            Assert.Equal(sandboxTag, metadata.Name);
+            Assert.Equal(AVEVA.Historian.Client.Models.HistorianDataType.Float, metadata.DataType);
+        }
+        finally
+        {
+            // Cleanup attempt — DeleteTags semantics still under investigation per the
+            // write-commands plan; even when DelT returns true the deletion may be
+            // asynchronous on the server. Don't assert post-delete state.
+            try { _ = await client.DeleteTagAsync(sandboxTag, CancellationToken.None); } catch { }
+        }
+    }
+
     [Fact]
     public async Task GetTagMetadataAsync_PopulatesDescriptionAndEuRangeForAnalogTag()
     {