Phase 7 Stream F — Admin UI for scripts + test harness + historian diagnostics

Adds the draft-editor tab + page surface for authoring Phase 7 virtual tags and
scripted alarms, plus the /alarms/historian operator diagnostics page. Monaco loads
from CDN via a progressive-enhancement JS shim — the textarea works immediately so
the page is functional even if the CDN is unreachable.

## New services (Admin)

- ScriptService — CRUD for Script entity. SHA-256 SourceHash recomputed on save so
  Core.Scripting's CompiledScriptCache hits on re-publish of unchanged source + misses
  when the source actually changes.
- VirtualTagService — CRUD for VirtualTag, with Enabled toggle.
- ScriptedAlarmService — CRUD for ScriptedAlarm + lookup of persistent ScriptedAlarmState
  (logical-id-keyed per plan decision #14).
- ScriptTestHarnessService — pre-publish dry-run. Enforces plan decision #22: only
  inputs the DependencyExtractor identifies can be supplied. Missing / extra synthetic
  inputs surface as dedicated outcomes. Captures SetVirtualTag writes + Serilog events
  from the script so the operator can see both the output + the log output before
  publishing.
- HistorianDiagnosticsService — surfaces the local-process IAlarmHistorianSink state
  on /alarms/historian. Null sink reports Disabled + swallows retry. Live
  SqliteStoreAndForwardSink reports real queue depth + last-error + drain state and
  routes the Retry-dead-lettered button through.

## New UI

- ScriptsTab.razor (inside DraftEditor tabs) — list + create/edit/delete scripts with
  Monaco editor + dependency preview + test-harness run panel showing output + writes
  + log emissions.
- ScriptEditor.razor — reusable Monaco-backed textarea. Loads editor from CDN via
  wwwroot/js/monaco-loader.js. Textarea stays authoritative for Blazor binding; Monaco
  mirrors into it on every keystroke.
- AlarmsHistorian.razor (/alarms/historian) — queue depth + dead-letter depth + drain
  state badge + last-error banner + Retry-dead-lettered button.
- DraftEditor.razor — new "Scripts" tab.

## DI wiring

All five services registered in Program.cs. Null historian sink bound at Admin
composition time (real SqliteStoreAndForwardSink lives in the Server process).

## Tests — 13/13

Phase7ServicesTests covers:
- ScriptService: Add generates logical id + hash, Update recomputes hash on source
  change, Update same-source keeps hash (cache-hit preservation), Delete is idempotent
- VirtualTagService: round-trips trigger flags, Enabled toggle works
- ScriptedAlarmService: HistorizeToAveva defaults true per plan decision #15
- ScriptTestHarness: successful run captures output + writes, rejects missing /
  extra inputs, rejects non-literal paths, compile errors surface as Threw
- HistorianDiagnosticsService: null sink reports Disabled + retry returns 0

src/ZB.MOM.WW.OtOpcUa.Admin/Services/ScriptService.cs

@@ -0,0 +1,66 @@
+using System.Security.Cryptography;
+using System.Text;
+using Microsoft.EntityFrameworkCore;
+using ZB.MOM.WW.OtOpcUa.Configuration;
+using ZB.MOM.WW.OtOpcUa.Configuration.Entities;
+
+namespace ZB.MOM.WW.OtOpcUa.Admin.Services;
+
+/// <summary>
+///     Draft-generation CRUD for <see cref="Script"/> rows — the C# source code referenced
+///     by Phase 7 virtual tags and scripted alarms. <see cref="Script.SourceHash"/> is
+///     recomputed on every save so Core.Scripting's compile cache sees a fresh key when
+///     source changes and reuses the compile when it doesn't.
+/// </summary>
+public sealed class ScriptService(OtOpcUaConfigDbContext db)
+{
+    public Task<List<Script>> ListAsync(long generationId, CancellationToken ct) =>
+        db.Scripts.AsNoTracking()
+            .Where(s => s.GenerationId == generationId)
+            .OrderBy(s => s.Name)
+            .ToListAsync(ct);
+
+    public Task<Script?> GetAsync(long generationId, string scriptId, CancellationToken ct) =>
+        db.Scripts.AsNoTracking()
+            .FirstOrDefaultAsync(s => s.GenerationId == generationId && s.ScriptId == scriptId, ct);
+
+    public async Task<Script> AddAsync(long generationId, string name, string sourceCode, CancellationToken ct)
+    {
+        var s = new Script
+        {
+            GenerationId = generationId,
+            ScriptId = $"scr-{Guid.NewGuid():N}"[..20],
+            Name = name,
+            SourceCode = sourceCode,
+            SourceHash = ComputeHash(sourceCode),
+        };
+        db.Scripts.Add(s);
+        await db.SaveChangesAsync(ct);
+        return s;
+    }
+
+    public async Task<Script> UpdateAsync(long generationId, string scriptId, string name, string sourceCode, CancellationToken ct)
+    {
+        var s = await db.Scripts.FirstOrDefaultAsync(x => x.GenerationId == generationId && x.ScriptId == scriptId, ct)
+            ?? throw new InvalidOperationException($"Script '{scriptId}' not found in generation {generationId}");
+        s.Name = name;
+        s.SourceCode = sourceCode;
+        s.SourceHash = ComputeHash(sourceCode);
+        await db.SaveChangesAsync(ct);
+        return s;
+    }
+
+    public async Task DeleteAsync(long generationId, string scriptId, CancellationToken ct)
+    {
+        var s = await db.Scripts.FirstOrDefaultAsync(x => x.GenerationId == generationId && x.ScriptId == scriptId, ct);
+        if (s is null) return;
+        db.Scripts.Remove(s);
+        await db.SaveChangesAsync(ct);
+    }
+
+    internal static string ComputeHash(string source)
+    {
+        var bytes = SHA256.HashData(Encoding.UTF8.GetBytes(source ?? string.Empty));
+        return Convert.ToHexString(bytes);
+    }
+}