up the blokcing tasks

src/Cli/StellaOps.Cli/Services/NotifyClient.cs

@@ -569,6 +569,131 @@ internal sealed class NotifyClient : INotifyClient
         }
     }
 
+    public async Task<NotifySimulationResult> SimulateAsync(
+        NotifySimulationRequest request,
+        CancellationToken cancellationToken)
+    {
+        ArgumentNullException.ThrowIfNull(request);
+
+        try
+        {
+            EnsureConfigured();
+
+            var json = JsonSerializer.Serialize(request, SerializerOptions);
+            using var content = new StringContent(json, Encoding.UTF8, "application/json");
+            using var httpRequest = new HttpRequestMessage(HttpMethod.Post, "/api/v2/simulate")
+            {
+                Content = content
+            };
+
+            if (!string.IsNullOrWhiteSpace(request.TenantId))
+            {
+                httpRequest.Headers.TryAddWithoutValidation("X-Tenant-Id", request.TenantId);
+            }
+
+            await AuthorizeRequestAsync(httpRequest, "notify.simulate", cancellationToken).ConfigureAwait(false);
+
+            using var response = await httpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false);
+            if (!response.IsSuccessStatusCode)
+            {
+                var payload = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                logger.LogError(
+                    "Failed to simulate notify rules (status {StatusCode}). Response: {Payload}",
+                    (int)response.StatusCode,
+                    string.IsNullOrWhiteSpace(payload) ? "<empty>" : payload);
+
+                return new NotifySimulationResult { SimulationId = null, TotalEvents = 0, TotalRules = 0 };
+            }
+
+            await using var stream = await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false);
+            var result = await JsonSerializer
+                .DeserializeAsync<NotifySimulationResult>(stream, SerializerOptions, cancellationToken)
+                .ConfigureAwait(false);
+
+            return result ?? new NotifySimulationResult { SimulationId = null, TotalEvents = 0, TotalRules = 0 };
+        }
+        catch (HttpRequestException ex)
+        {
+            logger.LogError(ex, "HTTP error while simulating notify rules");
+            return new NotifySimulationResult { SimulationId = null, TotalEvents = 0, TotalRules = 0 };
+        }
+        catch (TaskCanceledException ex) when (!cancellationToken.IsCancellationRequested)
+        {
+            logger.LogError(ex, "Request timed out while simulating notify rules");
+            return new NotifySimulationResult { SimulationId = null, TotalEvents = 0, TotalRules = 0 };
+        }
+    }
+
+    public async Task<NotifyAckResult> AckAsync(
+        NotifyAckRequest request,
+        CancellationToken cancellationToken)
+    {
+        ArgumentNullException.ThrowIfNull(request);
+
+        try
+        {
+            EnsureConfigured();
+
+            var hasToken = !string.IsNullOrWhiteSpace(request.Token);
+            using var httpRequest = hasToken
+                ? new HttpRequestMessage(HttpMethod.Get, $"/api/v2/ack?token={Uri.EscapeDataString(request.Token!)}")
+                : new HttpRequestMessage(HttpMethod.Post, "/api/v2/ack")
+                {
+                    Content = new StringContent(JsonSerializer.Serialize(new AckApiRequestBody
+                    {
+                        TenantId = request.TenantId,
+                        IncidentId = request.IncidentId,
+                        AcknowledgedBy = request.AcknowledgedBy,
+                        Comment = request.Comment
+                    }, SerializerOptions), Encoding.UTF8, "application/json")
+                };
+
+            if (!string.IsNullOrWhiteSpace(request.TenantId))
+            {
+                httpRequest.Headers.TryAddWithoutValidation("X-Tenant-Id", request.TenantId);
+            }
+
+            await AuthorizeRequestAsync(httpRequest, "notify.write", cancellationToken).ConfigureAwait(false);
+
+            using var response = await httpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false);
+            if (!response.IsSuccessStatusCode)
+            {
+                var payload = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                logger.LogError(
+                    "Failed to acknowledge notification (status {StatusCode}). Response: {Payload}",
+                    (int)response.StatusCode,
+                    string.IsNullOrWhiteSpace(payload) ? "<empty>" : payload);
+
+                return new NotifyAckResult { Success = false, IncidentId = request.IncidentId, Error = payload };
+            }
+
+            await using var stream = await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false);
+            var result = await JsonSerializer
+                .DeserializeAsync<NotifyAckResult>(stream, SerializerOptions, cancellationToken)
+                .ConfigureAwait(false);
+
+            return result ?? new NotifyAckResult { Success = true, IncidentId = request.IncidentId };
+        }
+        catch (HttpRequestException ex)
+        {
+            logger.LogError(ex, "HTTP error while acknowledging notification");
+            return new NotifyAckResult { Success = false, IncidentId = request.IncidentId, Error = ex.Message };
+        }
+        catch (TaskCanceledException ex) when (!cancellationToken.IsCancellationRequested)
+        {
+            logger.LogError(ex, "Request timed out while acknowledging notification");
+            return new NotifyAckResult { Success = false, IncidentId = request.IncidentId, Error = "Request timed out" };
+        }
+    }
+
+    private sealed record AckApiRequestBody
+    {
+        public string? TenantId { get; init; }
+        public string? IncidentId { get; init; }
+        public string? AcknowledgedBy { get; init; }
+        public string? Comment { get; init; }
+    }
+
     private static string BuildChannelListUri(NotifyChannelListRequest request)
     {
         var queryParams = new List<string>();