Add Policy DSL Validator, Schema Exporter, and Simulation Smoke tools

- Implemented PolicyDslValidator with command-line options for strict mode and JSON output.
- Created PolicySchemaExporter to generate JSON schemas for policy-related models.
- Developed PolicySimulationSmoke tool to validate policy simulations against expected outcomes.
- Added project files and necessary dependencies for each tool.
- Ensured proper error handling and usage instructions across tools.

src/StellaOps.Bench/Notify/StellaOps.Bench.Notify/Reporting/BenchmarkJsonWriter.cs

@@ -0,0 +1,147 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Threading;
+using System.Threading.Tasks;
+using StellaOps.Bench.Notify.Baseline;
+
+namespace StellaOps.Bench.Notify.Reporting;
+
+internal static class BenchmarkJsonWriter
+{
+    private static readonly JsonSerializerOptions SerializerOptions = new(JsonSerializerDefaults.Web)
+    {
+        WriteIndented = true,
+        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull
+    };
+
+    public static async Task WriteAsync(
+        string path,
+        BenchmarkJsonMetadata metadata,
+        IReadOnlyList<BenchmarkScenarioReport> reports,
+        CancellationToken cancellationToken)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(path);
+        ArgumentNullException.ThrowIfNull(metadata);
+        ArgumentNullException.ThrowIfNull(reports);
+
+        var resolved = Path.GetFullPath(path);
+        var directory = Path.GetDirectoryName(resolved);
+        if (!string.IsNullOrEmpty(directory))
+        {
+            Directory.CreateDirectory(directory);
+        }
+
+        var document = new BenchmarkJsonDocument(
+            metadata.SchemaVersion,
+            metadata.CapturedAtUtc,
+            metadata.Commit,
+            metadata.Environment,
+            reports.Select(CreateScenario).ToArray());
+
+        await using var stream = new FileStream(resolved, FileMode.Create, FileAccess.Write, FileShare.None);
+        await JsonSerializer.SerializeAsync(stream, document, SerializerOptions, cancellationToken).ConfigureAwait(false);
+        await stream.FlushAsync(cancellationToken).ConfigureAwait(false);
+    }
+
+    private static BenchmarkJsonScenario CreateScenario(BenchmarkScenarioReport report)
+    {
+        var baseline = report.Baseline;
+
+        return new BenchmarkJsonScenario(
+            report.Result.Id,
+            report.Result.Label,
+            report.Result.Iterations,
+            report.Result.TotalEvents,
+            report.Result.TotalRules,
+            report.Result.ActionsPerRule,
+            report.Result.AverageMatchesPerEvent,
+            report.Result.MinMatchesPerEvent,
+            report.Result.MaxMatchesPerEvent,
+            report.Result.AverageDeliveriesPerEvent,
+            report.Result.TotalDeliveries,
+            report.Result.MeanMs,
+            report.Result.P95Ms,
+            report.Result.MaxMs,
+            report.Result.MeanThroughputPerSecond,
+            report.Result.MinThroughputPerSecond,
+            report.Result.MaxAllocatedMb,
+            report.Result.ThresholdMs,
+            report.Result.MinThroughputThresholdPerSecond,
+            report.Result.MaxAllocatedThresholdMb,
+            baseline is null
+                ? null
+                : new BenchmarkJsonScenarioBaseline(
+                    baseline.Iterations,
+                    baseline.EventCount,
+                    baseline.DeliveryCount,
+                    baseline.MeanMs,
+                    baseline.P95Ms,
+                    baseline.MaxMs,
+                    baseline.MeanThroughputPerSecond,
+                    baseline.MinThroughputPerSecond,
+                    baseline.MaxAllocatedMb),
+            new BenchmarkJsonScenarioRegression(
+                report.DurationRegressionRatio,
+                report.ThroughputRegressionRatio,
+                report.RegressionLimit,
+                report.RegressionBreached));
+    }
+
+    private sealed record BenchmarkJsonDocument(
+        string SchemaVersion,
+        DateTimeOffset CapturedAt,
+        string? Commit,
+        string? Environment,
+        IReadOnlyList<BenchmarkJsonScenario> Scenarios);
+
+    private sealed record BenchmarkJsonScenario(
+        string Id,
+        string Label,
+        int Iterations,
+        int TotalEvents,
+        int TotalRules,
+        int ActionsPerRule,
+        double AverageMatchesPerEvent,
+        int MinMatchesPerEvent,
+        int MaxMatchesPerEvent,
+        double AverageDeliveriesPerEvent,
+        int TotalDeliveries,
+        double MeanMs,
+        double P95Ms,
+        double MaxMs,
+        double MeanThroughputPerSecond,
+        double MinThroughputPerSecond,
+        double MaxAllocatedMb,
+        double? ThresholdMs,
+        double? MinThroughputThresholdPerSecond,
+        double? MaxAllocatedThresholdMb,
+        BenchmarkJsonScenarioBaseline? Baseline,
+        BenchmarkJsonScenarioRegression Regression);
+
+    private sealed record BenchmarkJsonScenarioBaseline(
+        int Iterations,
+        int EventCount,
+        int DeliveryCount,
+        double MeanMs,
+        double P95Ms,
+        double MaxMs,
+        double MeanThroughputPerSecond,
+        double MinThroughputPerSecond,
+        double MaxAllocatedMb);
+
+    private sealed record BenchmarkJsonScenarioRegression(
+        double? DurationRatio,
+        double? ThroughputRatio,
+        double Limit,
+        bool Breached);
+}
+
+internal sealed record BenchmarkJsonMetadata(
+    string SchemaVersion,
+    DateTimeOffset CapturedAtUtc,
+    string? Commit,
+    string? Environment);

src/StellaOps.Bench/Notify/StellaOps.Bench.Notify/Reporting/BenchmarkScenarioReport.cs

@@ -0,0 +1,84 @@
+using System;
+using System.Collections.Generic;
+using StellaOps.Bench.Notify.Baseline;
+
+namespace StellaOps.Bench.Notify.Reporting;
+
+internal sealed class BenchmarkScenarioReport
+{
+    private const double DefaultRegressionLimit = 1.15d;
+
+    public BenchmarkScenarioReport(ScenarioResult result, BaselineEntry? baseline, double? regressionLimit = null)
+    {
+        Result = result ?? throw new ArgumentNullException(nameof(result));
+        Baseline = baseline;
+        RegressionLimit = regressionLimit is { } limit && limit > 0 ? limit : DefaultRegressionLimit;
+        DurationRegressionRatio = CalculateDurationRatio(result.MaxMs, baseline?.MaxMs);
+        ThroughputRegressionRatio = CalculateThroughputRatio(result.MinThroughputPerSecond, baseline?.MinThroughputPerSecond);
+    }
+
+    public ScenarioResult Result { get; }
+
+    public BaselineEntry? Baseline { get; }
+
+    public double RegressionLimit { get; }
+
+    public double? DurationRegressionRatio { get; }
+
+    public double? ThroughputRegressionRatio { get; }
+
+    public bool DurationRegressionBreached =>
+        DurationRegressionRatio is { } ratio &&
+        ratio >= RegressionLimit;
+
+    public bool ThroughputRegressionBreached =>
+        ThroughputRegressionRatio is { } ratio &&
+        ratio >= RegressionLimit;
+
+    public bool RegressionBreached => DurationRegressionBreached || ThroughputRegressionBreached;
+
+    public IEnumerable<string> BuildRegressionFailureMessages()
+    {
+        if (Baseline is null)
+        {
+            yield break;
+        }
+
+        if (DurationRegressionBreached && DurationRegressionRatio is { } durationRatio)
+        {
+            var delta = (durationRatio - 1d) * 100d;
+            yield return $"{Result.Id} exceeded max duration budget: {Result.MaxMs:F2} ms vs baseline {Baseline.MaxMs:F2} ms (+{delta:F1}%).";
+        }
+
+        if (ThroughputRegressionBreached && ThroughputRegressionRatio is { } throughputRatio)
+        {
+            var delta = (throughputRatio - 1d) * 100d;
+            yield return $"{Result.Id} throughput regressed: min {Result.MinThroughputPerSecond:N0} /s vs baseline {Baseline.MinThroughputPerSecond:N0} /s (-{delta:F1}%).";
+        }
+    }
+
+    private static double? CalculateDurationRatio(double current, double? baseline)
+    {
+        if (!baseline.HasValue || baseline.Value <= 0d)
+        {
+            return null;
+        }
+
+        return current / baseline.Value;
+    }
+
+    private static double? CalculateThroughputRatio(double current, double? baseline)
+    {
+        if (!baseline.HasValue || baseline.Value <= 0d)
+        {
+            return null;
+        }
+
+        if (current <= 0d)
+        {
+            return double.PositiveInfinity;
+        }
+
+        return baseline.Value / current;
+    }
+}

src/StellaOps.Bench/Notify/StellaOps.Bench.Notify/Reporting/PrometheusWriter.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Text;
+
+namespace StellaOps.Bench.Notify.Reporting;
+
+internal static class PrometheusWriter
+{
+    public static void Write(string path, IReadOnlyList<BenchmarkScenarioReport> reports)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(path);
+        ArgumentNullException.ThrowIfNull(reports);
+
+        var resolved = Path.GetFullPath(path);
+        var directory = Path.GetDirectoryName(resolved);
+        if (!string.IsNullOrEmpty(directory))
+        {
+            Directory.CreateDirectory(directory);
+        }
+
+        var builder = new StringBuilder();
+        builder.AppendLine("# HELP notify_dispatch_bench_duration_ms Notify dispatch benchmark duration metrics (milliseconds).");
+        builder.AppendLine("# TYPE notify_dispatch_bench_duration_ms gauge");
+        builder.AppendLine("# HELP notify_dispatch_bench_throughput_per_sec Notify dispatch benchmark throughput metrics (deliveries per second).");
+        builder.AppendLine("# TYPE notify_dispatch_bench_throughput_per_sec gauge");
+        builder.AppendLine("# HELP notify_dispatch_bench_allocation_mb Notify dispatch benchmark allocation metrics (megabytes).");
+        builder.AppendLine("# TYPE notify_dispatch_bench_allocation_mb gauge");
+
+        foreach (var report in reports)
+        {
+            var scenarioLabel = Escape(report.Result.Id);
+            AppendMetric(builder, "notify_dispatch_bench_mean_ms", scenarioLabel, report.Result.MeanMs);
+            AppendMetric(builder, "notify_dispatch_bench_p95_ms", scenarioLabel, report.Result.P95Ms);
+            AppendMetric(builder, "notify_dispatch_bench_max_ms", scenarioLabel, report.Result.MaxMs);
+            AppendMetric(builder, "notify_dispatch_bench_threshold_ms", scenarioLabel, report.Result.ThresholdMs);
+
+            AppendMetric(builder, "notify_dispatch_bench_mean_throughput_per_sec", scenarioLabel, report.Result.MeanThroughputPerSecond);
+            AppendMetric(builder, "notify_dispatch_bench_min_throughput_per_sec", scenarioLabel, report.Result.MinThroughputPerSecond);
+            AppendMetric(builder, "notify_dispatch_bench_min_throughput_threshold_per_sec", scenarioLabel, report.Result.MinThroughputThresholdPerSecond);
+
+            AppendMetric(builder, "notify_dispatch_bench_max_allocated_mb", scenarioLabel, report.Result.MaxAllocatedMb);
+            AppendMetric(builder, "notify_dispatch_bench_max_allocated_threshold_mb", scenarioLabel, report.Result.MaxAllocatedThresholdMb);
+
+            if (report.Baseline is { } baseline)
+            {
+                AppendMetric(builder, "notify_dispatch_bench_baseline_max_ms", scenarioLabel, baseline.MaxMs);
+                AppendMetric(builder, "notify_dispatch_bench_baseline_mean_ms", scenarioLabel, baseline.MeanMs);
+                AppendMetric(builder, "notify_dispatch_bench_baseline_min_throughput_per_sec", scenarioLabel, baseline.MinThroughputPerSecond);
+            }
+
+            if (report.DurationRegressionRatio is { } durationRatio)
+            {
+                AppendMetric(builder, "notify_dispatch_bench_duration_regression_ratio", scenarioLabel, durationRatio);
+            }
+
+            if (report.ThroughputRegressionRatio is { } throughputRatio)
+            {
+                AppendMetric(builder, "notify_dispatch_bench_throughput_regression_ratio", scenarioLabel, throughputRatio);
+            }
+
+            AppendMetric(builder, "notify_dispatch_bench_regression_limit", scenarioLabel, report.RegressionLimit);
+            AppendMetric(builder, "notify_dispatch_bench_regression_breached", scenarioLabel, report.RegressionBreached ? 1 : 0);
+        }
+
+        File.WriteAllText(resolved, builder.ToString(), Encoding.UTF8);
+    }
+
+    private static void AppendMetric(StringBuilder builder, string metric, string scenario, double? value)
+    {
+        if (!value.HasValue)
+        {
+            return;
+        }
+
+        builder.Append(metric);
+        builder.Append("{scenario=\"");
+        builder.Append(scenario);
+        builder.Append("\"} ");
+        builder.AppendLine(value.Value.ToString("G17", CultureInfo.InvariantCulture));
+    }
+
+    private static string Escape(string value) =>
+        value.Replace("\\", "\\\\", StringComparison.Ordinal).Replace("\"", "\\\"", StringComparison.Ordinal);
+}