feature: Trend Detection & Alert Suppression Windows

VigilCareClinicalAPI/BackgroundServices/TrendAnalyzerService.cs

@@ -0,0 +1,85 @@
+using System.Text.Json;
+using Confluent.Kafka;
+using Microsoft.Extensions.Options;
+
+public class TrendAnalyzerService : BackgroundService
+{
+    private readonly IServiceProvider _services;
+    private readonly KafkaOptions _kafkaOptions;
+    private readonly ILogger<TrendAnalyzerService> _logger;
+
+    public TrendAnalyzerService(
+        IServiceProvider services,
+        IOptions<KafkaOptions> kafkaOptions,
+        ILogger<TrendAnalyzerService> logger)
+    {
+        _services = services;
+        _kafkaOptions = kafkaOptions.Value;
+        _logger = logger;
+    }
+
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        var config = new ConsumerConfig
+        {
+            BootstrapServers = _kafkaOptions.BootstrapServers,
+            GroupId = "trend-analyzer",
+            AutoOffsetReset = AutoOffsetReset.Earliest,
+            EnableAutoCommit = false
+        };
+
+        using var consumer = new ConsumerBuilder<string, string>(config).Build();
+        consumer.Subscribe(_kafkaOptions.Topics.ObservationRecorded);
+
+        _logger.LogInformation("TrendAnalyzerService started — consumer group: trend-analyzer");
+
+        try
+        {
+            while (!stoppingToken.IsCancellationRequested)
+            {
+                ConsumeResult<string, string>? result = null;
+                try
+                {
+                    result = consumer.Consume(stoppingToken);
+
+                    var evt = JsonSerializer.Deserialize<TrendObservationEvent>(
+                        result.Message.Value,
+                        new JsonSerializerOptions { PropertyNameCaseInsensitive = true })!;
+
+                    using var scope = _services.CreateScope();
+                    var detector = scope.ServiceProvider.GetRequiredService<TrendDetector>();
+
+                    var outcome = await detector.ProcessObservationAsync(
+                        evt.EncounterId,
+                        evt.PatientId,
+                        evt.ObservationCode,
+                        evt.Value,
+                        evt.RecordedAt,
+                        stoppingToken);
+
+                    if (outcome.Outcome == TrendOutcome.RapidDeterioration)
+                        _logger.LogInformation(
+                            "RAPID_DETERIORATION alert via consumer — encounter={Id} code={Code} rate={Rate}/min",
+                            evt.EncounterId, outcome.ObservationCode, outcome.RatePerMinute);
+
+                    consumer.Commit(result);
+                }
+                catch (OperationCanceledException)
+                {
+                    break;
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex,
+                        "TrendAnalyzerService failed on topic={Topic} offset={Offset} — not committing",
+                        result?.Topic, result?.Offset.Value);
+                    await Task.Delay(2000, stoppingToken);
+                }
+            }
+        }
+        finally
+        {
+            consumer.Close();
+        }
+    }
+}

VigilCareClinicalAPI/Configuration/SuppressionOptions.cs

@@ -0,0 +1,7 @@
+public class SuppressionOptions
+{
+    public const string SectionName = "AlertSuppression";
+
+    /// <summary>Default suppression window after acknowledgment (minutes).</summary>
+    public int DefaultWindowMinutes { get; set; } = 30;
+}

VigilCareClinicalAPI/Configuration/TrendDetectionOptions.cs

@@ -0,0 +1,23 @@
+public class TrendDetectionOptions
+{
+    public const string SectionName = "TrendDetection";
+
+    /// <summary>Sliding window for rate-of-change calculation (minutes).</summary>
+    public int WindowMinutes { get; set; } = 30;
+
+    /// <summary>Maximum history entries stored per parameter in Redis.</summary>
+    public int MaxHistoryEntries { get; set; } = 10;
+
+    /// <summary>Redis TTL for trend history keys (seconds). Default 2 hours.</summary>
+    public int HistoryTtlSeconds { get; set; } = 7200;
+
+    /// <summary>Per-code rate thresholds: units per minute.</summary>
+    public Dictionary<string, decimal> RateThresholdsPerMinute { get; set; } = new()
+    {
+        ["HEART_RATE"]   = 0.5m,   // 15 bpm rise in 30 min
+        ["RESP_RATE"]    = 0.3m,   // 9 breaths/min rise in 30 min
+        ["SYSTOLIC_BP"]  = 1.0m,   // 30 mmHg drop in 30 min (negative rate checked separately)
+        ["TEMP_C"]       = 0.05m,  // 1.5 °C rise in 30 min
+        ["SPO2"]         = 0.2m    // 6% drop in 30 min (negative rate)
+    };
+}

VigilCareClinicalAPI/Data/Configurations/AlertThresholdConfiguration.cs

@@ -15,6 +15,7 @@ public class AlertThresholdConfiguration : IEntityTypeConfiguration<AlertThresho
         builder.Property(t => t.WarningLow).HasColumnName("warning_low").HasColumnType("decimal(10,3)");
         builder.Property(t => t.WarningHigh).HasColumnName("warning_high").HasColumnType("decimal(10,3)");
         builder.Property(t => t.CriticalHigh).HasColumnName("critical_high").HasColumnType("decimal(10,3)");
+        builder.Property(t => t.SuppressionWindowMinutes).HasColumnName("suppression_window_minutes");
         builder.Property(t => t.CreatedAt).HasColumnName("created_at").HasDefaultValueSql("NOW()");
 
         builder.HasIndex(t => t.ObservationCode).IsUnique();

VigilCareClinicalAPI/Domains/Entities/AlertThreshold.cs

@@ -8,5 +8,6 @@ public class AlertThreshold
     public decimal? WarningLow { get; set; }
     public decimal? WarningHigh { get; set; }
     public decimal? CriticalHigh { get; set; }
+    public int? SuppressionWindowMinutes { get; set; }
     public DateTimeOffset CreatedAt { get; set; }
 }

VigilCareClinicalAPI/Domains/Enums/AlertType.cs

@@ -26,7 +26,9 @@ public enum AlertType
     WarningGlucoseMgDl,
 
     News2Warning,
-    News2Emergency
+    News2Emergency,
+
+    RapidDeterioration,
 }
 
 public static class AlertTypeExtensions
@@ -57,6 +59,7 @@ public static class AlertTypeExtensions
         AlertType.WarningGlucoseMgDl    => "WARNING_GLUCOSE_MG_DL",
         AlertType.News2Warning   => "NEWS2_WARNING",
         AlertType.News2Emergency => "NEWS2_EMERGENCY",
+        AlertType.RapidDeterioration => "RAPID_DETERIORATION",
         _ => throw new ArgumentOutOfRangeException(nameof(t))
     };
 
@@ -86,6 +89,7 @@ public static class AlertTypeExtensions
         "WARNING_GLUCOSE_MG_DL"   => AlertType.WarningGlucoseMgDl,
         "NEWS2_WARNING"   => AlertType.News2Warning,
         "NEWS2_EMERGENCY" => AlertType.News2Emergency,
+        "RAPID_DETERIORATION" => AlertType.RapidDeterioration,
         _ => throw new ArgumentOutOfRangeException(nameof(v), $"Unknown alert type: '{v}'")
     };
 
@@ -122,4 +126,31 @@ public static class AlertTypeExtensions
         _ => throw new ArgumentOutOfRangeException(
             nameof(observationCode), $"No warning alert type for observation code '{observationCode}'")
     };
+
+    public static bool IsSuppressible(this AlertType t) => t switch
+    {
+        AlertType.SepsisWarning or AlertType.News2Emergency => false,
+        AlertType.CriticalHeartRate or AlertType.CriticalTempC or AlertType.CriticalPotassiumMeqL
+            or AlertType.CriticalSpo2 or AlertType.CriticalRespRate or AlertType.CriticalWbcKUl
+            or AlertType.CriticalSystolicBp or AlertType.CriticalDiastolicBp
+            or AlertType.CriticalLactateMmolL or AlertType.CriticalAvpu
+            or AlertType.CriticalGlucoseMgDl => false,
+        AlertType.RapidDeterioration => false,  // trajectory alerts are never suppressed
+        _ => true  // all Warning* types and News2Warning
+    };
+
+    public static string? ObservationCodeForWarning(this AlertType t) => t switch
+    {
+        AlertType.WarningHeartRate      => "HEART_RATE",
+        AlertType.WarningTempC          => "TEMP_C",
+        AlertType.WarningPotassiumMeqL  => "POTASSIUM_MEQ_L",
+        AlertType.WarningSpo2           => "SPO2",
+        AlertType.WarningRespRate       => "RESP_RATE",
+        AlertType.WarningWbcKUl         => "WBC_K_UL",
+        AlertType.WarningSystolicBp     => "SYSTOLIC_BP",
+        AlertType.WarningDiastolicBp    => "DIASTOLIC_BP",
+        AlertType.WarningLactateMmolL   => "LACTATE_MMOL_L",
+        AlertType.WarningGlucoseMgDl    => "GLUCOSE_MG_DL",
+        _ => null
+    };
 }

VigilCareClinicalAPI/Domains/Enums/TrendOutcome.cs

@@ -0,0 +1,8 @@
+public enum TrendOutcome
+{
+    NotTrendCode,
+    InsufficientHistory,
+    Stable,
+    RapidDeterioration,
+    AlertAlreadyOpen
+}

VigilCareClinicalAPI/Migrations/20260618121634_AddRapidDeteriorationAlertType.Designer.cs

@@ -0,0 +1,716 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace VigilCareClinicalAPI.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20260618121634_AddRapidDeteriorationAlertType")]
+    partial class AddRapidDeteriorationAlertType
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.4")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("AlertThreshold", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("id")
+                        .HasDefaultValueSql("gen_random_uuid()");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<decimal?>("CriticalHigh")
+                        .HasColumnType("decimal(10,3)")
+                        .HasColumnName("critical_high");
+
+                    b.Property<decimal?>("CriticalLow")
+                        .HasColumnType("decimal(10,3)")
+                        .HasColumnName("critical_low");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("display_name");
+
+                    b.Property<string>("ObservationCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("observation_code");
+
+                    b.Property<string>("Unit")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)")
+                        .HasColumnName("unit");
+
+                    b.Property<decimal?>("WarningHigh")
+                        .HasColumnType("decimal(10,3)")
+                        .HasColumnName("warning_high");
+
+                    b.Property<decimal?>("WarningLow")
+                        .HasColumnType("decimal(10,3)")
+                        .HasColumnName("warning_low");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ObservationCode")
+                        .IsUnique();
+
+                    b.ToTable("alert_thresholds", (string)null);
+                });
+
+            modelBuilder.Entity("ClinicalAlert", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("id")
+                        .HasDefaultValueSql("gen_random_uuid()");
+
+                    b.Property<DateTimeOffset?>("AcknowledgedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("acknowledged_at");
+
+                    b.Property<string>("AcknowledgedBy")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("acknowledged_by");
+
+                    b.Property<string>("AlertType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("alert_type");
+
+                    b.Property<string>("Details")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("details");
+
+                    b.Property<Guid>("EncounterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("encounter_id");
+
+                    b.Property<Guid?>("ObservationId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("observation_id");
+
+                    b.Property<Guid>("PatientId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("patient_id");
+
+                    b.Property<DateTimeOffset?>("ResolvedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("resolved_at");
+
+                    b.Property<string>("Severity")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)")
+                        .HasColumnName("severity");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)")
+                        .HasColumnName("status")
+                        .HasDefaultValueSql("'OPEN'");
+
+                    b.Property<DateTimeOffset>("TriggeredAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("triggered_at")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EncounterId", "TriggeredAt");
+
+                    b.HasIndex("PatientId", "TriggeredAt");
+
+                    b.HasIndex("Severity", "TriggeredAt")
+                        .HasFilter("status = 'OPEN'");
+
+                    b.ToTable("clinical_alerts", null, t =>
+                        {
+                            t.HasCheckConstraint("chk_clinical_alerts_alert_type", "alert_type IN ('SEPSIS_WARNING', 'CRITICAL_HEART_RATE', 'CRITICAL_TEMP_C', 'CRITICAL_POTASSIUM_MEQ_L', 'CRITICAL_SPO2', 'CRITICAL_RESP_RATE', 'CRITICAL_WBC_K_UL')");
+
+                            t.HasCheckConstraint("chk_clinical_alerts_severity", "severity IN ('WARNING', 'CRITICAL')");
+
+                            t.HasCheckConstraint("chk_clinical_alerts_status", "status IN ('OPEN', 'ACKNOWLEDGED', 'RESOLVED', 'ESCALATED')");
+                        });
+                });
+
+            modelBuilder.Entity("Encounter", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("id")
+                        .HasDefaultValueSql("gen_random_uuid()");
+
+                    b.Property<string>("AdmissionReason")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)")
+                        .HasColumnName("admission_reason");
+
+                    b.Property<DateTimeOffset>("AdmittedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("admitted_at")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("AttendingPhysician")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("attending_physician");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Department")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)")
+                        .HasColumnName("department");
+
+                    b.Property<string>("DischargeDiagnosis")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)")
+                        .HasColumnName("discharge_diagnosis");
+
+                    b.Property<DateTimeOffset?>("DischargedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("discharged_at");
+
+                    b.Property<string>("EncounterType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)")
+                        .HasColumnName("encounter_type");
+
+                    b.Property<Guid>("PatientId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("patient_id");
+
+                    b.Property<string>("RoomBed")
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)")
+                        .HasColumnName("room_bed");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)")
+                        .HasColumnName("status")
+                        .HasDefaultValueSql("'SCHEDULED'");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PatientId", "AdmittedAt");
+
+                    b.HasIndex("Status", "AdmittedAt")
+                        .HasFilter("status = 'ACTIVE'");
+
+                    b.ToTable("encounters", null, t =>
+                        {
+                            t.HasCheckConstraint("chk_encounters_department", "department IN ('ICU', 'GENERAL_MEDICINE', 'EMERGENCY', 'CARDIOLOGY', 'SURGERY', 'PEDIATRICS')");
+
+                            t.HasCheckConstraint("chk_encounters_encounter_type", "encounter_type IN ('INPATIENT', 'OUTPATIENT', 'EMERGENCY')");
+
+                            t.HasCheckConstraint("chk_encounters_status", "status IN ('SCHEDULED', 'ACTIVE', 'DISCHARGED', 'CANCELLED')");
+                        });
+                });
+
+            modelBuilder.Entity("News2Score", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("id")
+                        .HasDefaultValueSql("gen_random_uuid()");
+
+                    b.Property<DateTimeOffset>("CalculatedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("calculated_at");
+
+                    b.Property<int>("ConsciousnessScore")
+                        .HasColumnType("integer")
+                        .HasColumnName("consciousness_score");
+
+                    b.Property<Guid>("EncounterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("encounter_id");
+
+                    b.Property<bool>("HasSingleParamThree")
+                        .HasColumnType("boolean")
+                        .HasColumnName("has_single_param_three");
+
+                    b.Property<int>("HeartRateScore")
+                        .HasColumnType("integer")
+                        .HasColumnName("heart_rate_score");
+
+                    b.Property<Guid>("PatientId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("patient_id");
+
+                    b.Property<int>("RespRateScore")
+                        .HasColumnType("integer")
+                        .HasColumnName("resp_rate_score");
+
+                    b.Property<string>("RiskLevel")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)")
+                        .HasColumnName("risk_level");
+
+                    b.Property<int>("Spo2Score")
+                        .HasColumnType("integer")
+                        .HasColumnName("spo2_score");
+
+                    b.Property<int>("SupplementalO2Score")
+                        .HasColumnType("integer")
+                        .HasColumnName("supplemental_o2_score");
+
+                    b.Property<int>("SystolicBpScore")
+                        .HasColumnType("integer")
+                        .HasColumnName("systolic_bp_score");
+
+                    b.Property<int>("TemperatureScore")
+                        .HasColumnType("integer")
+                        .HasColumnName("temperature_score");
+
+                    b.Property<int>("TotalScore")
+                        .HasColumnType("integer")
+                        .HasColumnName("total_score");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EncounterId", "CalculatedAt");
+
+                    b.HasIndex("PatientId", "CalculatedAt");
+
+                    b.ToTable("news2_scores", null, t =>
+                        {
+                            t.HasCheckConstraint("chk_news2_scores_risk_level", "risk_level IN ('LOW', 'LOW_MEDIUM', 'MEDIUM', 'HIGH')");
+                        });
+                });
+
+            modelBuilder.Entity("Observation", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("id")
+                        .HasDefaultValueSql("gen_random_uuid()");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<Guid>("EncounterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("encounter_id");
+
+                    b.Property<string>("IdempotencyKey")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)")
+                        .HasColumnName("idempotency_key");
+
+                    b.Property<string>("ObservationCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("observation_code");
+
+                    b.Property<DateTimeOffset>("RecordedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("recorded_at");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)")
+                        .HasColumnName("source")
+                        .HasDefaultValueSql("'MANUAL'");
+
+                    b.Property<string>("Unit")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)")
+                        .HasColumnName("unit");
+
+                    b.Property<decimal>("Value")
+                        .HasColumnType("decimal(10,3)")
+                        .HasColumnName("value");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IdempotencyKey")
+                        .IsUnique()
+                        .HasFilter("idempotency_key IS NOT NULL");
+
+                    b.HasIndex("EncounterId", "ObservationCode", "RecordedAt");
+
+                    b.ToTable("observations", null, t =>
+                        {
+                            t.HasCheckConstraint("chk_observations_source", "source IN ('MANUAL', 'DEVICE', 'LAB')");
+                        });
+                });
+
+            modelBuilder.Entity("Order", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("id")
+                        .HasDefaultValueSql("gen_random_uuid()");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("description");
+
+                    b.Property<Guid>("EncounterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("encounter_id");
+
+                    b.Property<string>("OrderType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)")
+                        .HasColumnName("order_type");
+
+                    b.Property<DateTimeOffset>("OrderedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("ordered_at")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("OrderedBy")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("ordered_by");
+
+                    b.Property<string>("ResultSummary")
+                        .HasColumnType("text")
+                        .HasColumnName("result_summary");
+
+                    b.Property<DateTimeOffset?>("ResultedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("resulted_at");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)")
+                        .HasColumnName("status")
+                        .HasDefaultValueSql("'PENDING'");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EncounterId", "OrderedAt");
+
+                    b.HasIndex("Status", "OrderedAt")
+                        .HasFilter("status IN ('PENDING', 'IN_PROGRESS')");
+
+                    b.ToTable("orders", null, t =>
+                        {
+                            t.HasCheckConstraint("chk_orders_order_type", "order_type IN ('LAB', 'IMAGING', 'MEDICATION', 'PROCEDURE')");
+
+                            t.HasCheckConstraint("chk_orders_status", "status IN ('PENDING', 'IN_PROGRESS', 'RESULTED', 'CANCELLED')");
+                        });
+                });
+
+            modelBuilder.Entity("OutboxEvent", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("id")
+                        .HasDefaultValueSql("gen_random_uuid()");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("PartitionKey")
+                        .HasMaxLength(36)
+                        .HasColumnType("character varying(36)")
+                        .HasColumnName("partition_key");
+
+                    b.Property<string>("Payload")
+                        .IsRequired()
+                        .HasColumnType("jsonb")
+                        .HasColumnName("payload");
+
+                    b.Property<DateTimeOffset?>("ProcessedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("processed_at");
+
+                    b.Property<string>("Topic")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("topic");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedAt")
+                        .HasFilter("processed_at IS NULL");
+
+                    b.ToTable("outbox_events", (string)null);
+                });
+
+            modelBuilder.Entity("Patient", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("id")
+                        .HasDefaultValueSql("gen_random_uuid()");
+
+                    b.Property<string>("Allergies")
+                        .HasColumnType("text")
+                        .HasColumnName("allergies");
+
+                    b.Property<string>("BloodType")
+                        .HasMaxLength(5)
+                        .HasColumnType("character varying(5)")
+                        .HasColumnName("blood_type");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<DateOnly>("DateOfBirth")
+                        .HasColumnType("date")
+                        .HasColumnName("date_of_birth");
+
+                    b.Property<string>("EmergencyContactName")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("emergency_contact_name");
+
+                    b.Property<string>("EmergencyContactPhone")
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)")
+                        .HasColumnName("emergency_contact_phone");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)")
+                        .HasColumnName("first_name");
+
+                    b.Property<string>("Gender")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)")
+                        .HasColumnName("gender");
+
+                    b.Property<string>("LastName")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)")
+                        .HasColumnName("last_name");
+
+                    b.Property<string>("Mrn")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)")
+                        .HasColumnName("mrn");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)")
+                        .HasDefaultValue("active")
+                        .HasColumnName("status");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Mrn")
+                        .IsUnique();
+
+                    b.ToTable("patients", (string)null);
+                });
+
+            modelBuilder.Entity("ReconciliationAlert", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("id")
+                        .HasDefaultValueSql("gen_random_uuid()");
+
+                    b.Property<string>("CheckType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("check_type");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Details")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("details");
+
+                    b.Property<Guid?>("EncounterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("encounter_id");
+
+                    b.Property<Guid?>("PatientId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("patient_id");
+
+                    b.Property<DateTimeOffset?>("ResolvedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("resolved_at");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EncounterId");
+
+                    b.HasIndex("PatientId");
+
+                    b.HasIndex("CheckType", "EncounterId")
+                        .HasFilter("resolved_at IS NULL");
+
+                    b.ToTable("reconciliation_alerts", null, t =>
+                        {
+                            t.HasCheckConstraint("chk_reconciliation_alerts_check_type", "check_type IN ('UNACKNOWLEDGED_CRITICAL_ALERT', 'PENDING_ORDER_NO_RESULT', 'ACTIVE_INPATIENT_NO_OBSERVATION')");
+                        });
+                });
+
+            modelBuilder.Entity("ClinicalAlert", b =>
+                {
+                    b.HasOne("Encounter", "Encounter")
+                        .WithMany("Alerts")
+                        .HasForeignKey("EncounterId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Encounter");
+                });
+
+            modelBuilder.Entity("Encounter", b =>
+                {
+                    b.HasOne("Patient", "Patient")
+                        .WithMany("Encounters")
+                        .HasForeignKey("PatientId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Patient");
+                });
+
+            modelBuilder.Entity("News2Score", b =>
+                {
+                    b.HasOne("Encounter", "Encounter")
+                        .WithMany()
+                        .HasForeignKey("EncounterId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Encounter");
+                });
+
+            modelBuilder.Entity("Observation", b =>
+                {
+                    b.HasOne("Encounter", "Encounter")
+                        .WithMany("Observations")
+                        .HasForeignKey("EncounterId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Encounter");
+                });
+
+            modelBuilder.Entity("Order", b =>
+                {
+                    b.HasOne("Encounter", "Encounter")
+                        .WithMany("Orders")
+                        .HasForeignKey("EncounterId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Encounter");
+                });
+
+            modelBuilder.Entity("ReconciliationAlert", b =>
+                {
+                    b.HasOne("Encounter", "Encounter")
+                        .WithMany()
+                        .HasForeignKey("EncounterId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("Patient", "Patient")
+                        .WithMany()
+                        .HasForeignKey("PatientId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Encounter");
+
+                    b.Navigation("Patient");
+                });
+
+            modelBuilder.Entity("Encounter", b =>
+                {
+                    b.Navigation("Alerts");
+
+                    b.Navigation("Observations");
+
+                    b.Navigation("Orders");
+                });
+
+            modelBuilder.Entity("Patient", b =>
+                {
+                    b.Navigation("Encounters");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

VigilCareClinicalAPI/Migrations/20260618121634_AddRapidDeteriorationAlertType.cs

@@ -0,0 +1,36 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace VigilCareClinicalAPI.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddRapidDeteriorationAlertType : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.Sql("""
+                ALTER TABLE clinical_alerts DROP CONSTRAINT chk_clinical_alerts_alert_type;
+                ALTER TABLE clinical_alerts ADD CONSTRAINT chk_clinical_alerts_alert_type
+                    CHECK (alert_type IN (
+                        'SEPSIS_WARNING',
+                        'CRITICAL_HEART_RATE', 'CRITICAL_TEMP_C', 'CRITICAL_POTASSIUM_MEQ_L',
+                        'CRITICAL_SPO2', 'CRITICAL_RESP_RATE', 'CRITICAL_WBC_K_UL',
+                        'CRITICAL_SYSTOLIC_BP', 'CRITICAL_DIASTOLIC_BP', 'CRITICAL_LACTATE_MMOL_L',
+                        'CRITICAL_AVPU', 'CRITICAL_GLUCOSE_MG_DL',
+                        'WARNING_HEART_RATE', 'WARNING_TEMP_C', 'WARNING_POTASSIUM_MEQ_L',
+                        'WARNING_SPO2', 'WARNING_RESP_RATE', 'WARNING_WBC_K_UL',
+                        'WARNING_SYSTOLIC_BP', 'WARNING_DIASTOLIC_BP', 'WARNING_LACTATE_MMOL_L',
+                        'WARNING_GLUCOSE_MG_DL', 'NEWS2_WARNING', 'NEWS2_EMERGENCY', 'RAPID_DETERIORATION'
+                    ));
+                """);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+
+        }
+    }
+}

VigilCareClinicalAPI/Migrations/20260618124632_AddSuppressionWindowMinutes.Designer.cs

@@ -0,0 +1,720 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace VigilCareClinicalAPI.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20260618124632_AddSuppressionWindowMinutes")]
+    partial class AddSuppressionWindowMinutes
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.4")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("AlertThreshold", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("id")
+                        .HasDefaultValueSql("gen_random_uuid()");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<decimal?>("CriticalHigh")
+                        .HasColumnType("decimal(10,3)")
+                        .HasColumnName("critical_high");
+
+                    b.Property<decimal?>("CriticalLow")
+                        .HasColumnType("decimal(10,3)")
+                        .HasColumnName("critical_low");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("display_name");
+
+                    b.Property<string>("ObservationCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("observation_code");
+
+                    b.Property<int?>("SuppressionWindowMinutes")
+                        .HasColumnType("integer")
+                        .HasColumnName("suppression_window_minutes");
+
+                    b.Property<string>("Unit")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)")
+                        .HasColumnName("unit");
+
+                    b.Property<decimal?>("WarningHigh")
+                        .HasColumnType("decimal(10,3)")
+                        .HasColumnName("warning_high");
+
+                    b.Property<decimal?>("WarningLow")
+                        .HasColumnType("decimal(10,3)")
+                        .HasColumnName("warning_low");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ObservationCode")
+                        .IsUnique();
+
+                    b.ToTable("alert_thresholds", (string)null);
+                });
+
+            modelBuilder.Entity("ClinicalAlert", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("id")
+                        .HasDefaultValueSql("gen_random_uuid()");
+
+                    b.Property<DateTimeOffset?>("AcknowledgedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("acknowledged_at");
+
+                    b.Property<string>("AcknowledgedBy")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("acknowledged_by");
+
+                    b.Property<string>("AlertType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("alert_type");
+
+                    b.Property<string>("Details")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("details");
+
+                    b.Property<Guid>("EncounterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("encounter_id");
+
+                    b.Property<Guid?>("ObservationId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("observation_id");
+
+                    b.Property<Guid>("PatientId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("patient_id");
+
+                    b.Property<DateTimeOffset?>("ResolvedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("resolved_at");
+
+                    b.Property<string>("Severity")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)")
+                        .HasColumnName("severity");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)")
+                        .HasColumnName("status")
+                        .HasDefaultValueSql("'OPEN'");
+
+                    b.Property<DateTimeOffset>("TriggeredAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("triggered_at")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EncounterId", "TriggeredAt");
+
+                    b.HasIndex("PatientId", "TriggeredAt");
+
+                    b.HasIndex("Severity", "TriggeredAt")
+                        .HasFilter("status = 'OPEN'");
+
+                    b.ToTable("clinical_alerts", null, t =>
+                        {
+                            t.HasCheckConstraint("chk_clinical_alerts_alert_type", "alert_type IN ('SEPSIS_WARNING', 'CRITICAL_HEART_RATE', 'CRITICAL_TEMP_C', 'CRITICAL_POTASSIUM_MEQ_L', 'CRITICAL_SPO2', 'CRITICAL_RESP_RATE', 'CRITICAL_WBC_K_UL')");
+
+                            t.HasCheckConstraint("chk_clinical_alerts_severity", "severity IN ('WARNING', 'CRITICAL')");
+
+                            t.HasCheckConstraint("chk_clinical_alerts_status", "status IN ('OPEN', 'ACKNOWLEDGED', 'RESOLVED', 'ESCALATED')");
+                        });
+                });
+
+            modelBuilder.Entity("Encounter", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("id")
+                        .HasDefaultValueSql("gen_random_uuid()");
+
+                    b.Property<string>("AdmissionReason")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)")
+                        .HasColumnName("admission_reason");
+
+                    b.Property<DateTimeOffset>("AdmittedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("admitted_at")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("AttendingPhysician")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("attending_physician");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Department")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)")
+                        .HasColumnName("department");
+
+                    b.Property<string>("DischargeDiagnosis")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)")
+                        .HasColumnName("discharge_diagnosis");
+
+                    b.Property<DateTimeOffset?>("DischargedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("discharged_at");
+
+                    b.Property<string>("EncounterType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)")
+                        .HasColumnName("encounter_type");
+
+                    b.Property<Guid>("PatientId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("patient_id");
+
+                    b.Property<string>("RoomBed")
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)")
+                        .HasColumnName("room_bed");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)")
+                        .HasColumnName("status")
+                        .HasDefaultValueSql("'SCHEDULED'");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PatientId", "AdmittedAt");
+
+                    b.HasIndex("Status", "AdmittedAt")
+                        .HasFilter("status = 'ACTIVE'");
+
+                    b.ToTable("encounters", null, t =>
+                        {
+                            t.HasCheckConstraint("chk_encounters_department", "department IN ('ICU', 'GENERAL_MEDICINE', 'EMERGENCY', 'CARDIOLOGY', 'SURGERY', 'PEDIATRICS')");
+
+                            t.HasCheckConstraint("chk_encounters_encounter_type", "encounter_type IN ('INPATIENT', 'OUTPATIENT', 'EMERGENCY')");
+
+                            t.HasCheckConstraint("chk_encounters_status", "status IN ('SCHEDULED', 'ACTIVE', 'DISCHARGED', 'CANCELLED')");
+                        });
+                });
+
+            modelBuilder.Entity("News2Score", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("id")
+                        .HasDefaultValueSql("gen_random_uuid()");
+
+                    b.Property<DateTimeOffset>("CalculatedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("calculated_at");
+
+                    b.Property<int>("ConsciousnessScore")
+                        .HasColumnType("integer")
+                        .HasColumnName("consciousness_score");
+
+                    b.Property<Guid>("EncounterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("encounter_id");
+
+                    b.Property<bool>("HasSingleParamThree")
+                        .HasColumnType("boolean")
+                        .HasColumnName("has_single_param_three");
+
+                    b.Property<int>("HeartRateScore")
+                        .HasColumnType("integer")
+                        .HasColumnName("heart_rate_score");
+
+                    b.Property<Guid>("PatientId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("patient_id");
+
+                    b.Property<int>("RespRateScore")
+                        .HasColumnType("integer")
+                        .HasColumnName("resp_rate_score");
+
+                    b.Property<string>("RiskLevel")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)")
+                        .HasColumnName("risk_level");
+
+                    b.Property<int>("Spo2Score")
+                        .HasColumnType("integer")
+                        .HasColumnName("spo2_score");
+
+                    b.Property<int>("SupplementalO2Score")
+                        .HasColumnType("integer")
+                        .HasColumnName("supplemental_o2_score");
+
+                    b.Property<int>("SystolicBpScore")
+                        .HasColumnType("integer")
+                        .HasColumnName("systolic_bp_score");
+
+                    b.Property<int>("TemperatureScore")
+                        .HasColumnType("integer")
+                        .HasColumnName("temperature_score");
+
+                    b.Property<int>("TotalScore")
+                        .HasColumnType("integer")
+                        .HasColumnName("total_score");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EncounterId", "CalculatedAt");
+
+                    b.HasIndex("PatientId", "CalculatedAt");
+
+                    b.ToTable("news2_scores", null, t =>
+                        {
+                            t.HasCheckConstraint("chk_news2_scores_risk_level", "risk_level IN ('LOW', 'LOW_MEDIUM', 'MEDIUM', 'HIGH')");
+                        });
+                });
+
+            modelBuilder.Entity("Observation", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("id")
+                        .HasDefaultValueSql("gen_random_uuid()");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<Guid>("EncounterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("encounter_id");
+
+                    b.Property<string>("IdempotencyKey")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)")
+                        .HasColumnName("idempotency_key");
+
+                    b.Property<string>("ObservationCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("observation_code");
+
+                    b.Property<DateTimeOffset>("RecordedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("recorded_at");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)")
+                        .HasColumnName("source")
+                        .HasDefaultValueSql("'MANUAL'");
+
+                    b.Property<string>("Unit")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)")
+                        .HasColumnName("unit");
+
+                    b.Property<decimal>("Value")
+                        .HasColumnType("decimal(10,3)")
+                        .HasColumnName("value");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IdempotencyKey")
+                        .IsUnique()
+                        .HasFilter("idempotency_key IS NOT NULL");
+
+                    b.HasIndex("EncounterId", "ObservationCode", "RecordedAt");
+
+                    b.ToTable("observations", null, t =>
+                        {
+                            t.HasCheckConstraint("chk_observations_source", "source IN ('MANUAL', 'DEVICE', 'LAB')");
+                        });
+                });
+
+            modelBuilder.Entity("Order", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("id")
+                        .HasDefaultValueSql("gen_random_uuid()");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("description");
+
+                    b.Property<Guid>("EncounterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("encounter_id");
+
+                    b.Property<string>("OrderType")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)")
+                        .HasColumnName("order_type");
+
+                    b.Property<DateTimeOffset>("OrderedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("ordered_at")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("OrderedBy")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("ordered_by");
+
+                    b.Property<string>("ResultSummary")
+                        .HasColumnType("text")
+                        .HasColumnName("result_summary");
+
+                    b.Property<DateTimeOffset?>("ResultedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("resulted_at");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)")
+                        .HasColumnName("status")
+                        .HasDefaultValueSql("'PENDING'");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EncounterId", "OrderedAt");
+
+                    b.HasIndex("Status", "OrderedAt")
+                        .HasFilter("status IN ('PENDING', 'IN_PROGRESS')");
+
+                    b.ToTable("orders", null, t =>
+                        {
+                            t.HasCheckConstraint("chk_orders_order_type", "order_type IN ('LAB', 'IMAGING', 'MEDICATION', 'PROCEDURE')");
+
+                            t.HasCheckConstraint("chk_orders_status", "status IN ('PENDING', 'IN_PROGRESS', 'RESULTED', 'CANCELLED')");
+                        });
+                });
+
+            modelBuilder.Entity("OutboxEvent", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("id")
+                        .HasDefaultValueSql("gen_random_uuid()");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("PartitionKey")
+                        .HasMaxLength(36)
+                        .HasColumnType("character varying(36)")
+                        .HasColumnName("partition_key");
+
+                    b.Property<string>("Payload")
+                        .IsRequired()
+                        .HasColumnType("jsonb")
+                        .HasColumnName("payload");
+
+                    b.Property<DateTimeOffset?>("ProcessedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("processed_at");
+
+                    b.Property<string>("Topic")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("topic");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedAt")
+                        .HasFilter("processed_at IS NULL");
+
+                    b.ToTable("outbox_events", (string)null);
+                });
+
+            modelBuilder.Entity("Patient", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("id")
+                        .HasDefaultValueSql("gen_random_uuid()");
+
+                    b.Property<string>("Allergies")
+                        .HasColumnType("text")
+                        .HasColumnName("allergies");
+
+                    b.Property<string>("BloodType")
+                        .HasMaxLength(5)
+                        .HasColumnType("character varying(5)")
+                        .HasColumnName("blood_type");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<DateOnly>("DateOfBirth")
+                        .HasColumnType("date")
+                        .HasColumnName("date_of_birth");
+
+                    b.Property<string>("EmergencyContactName")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("emergency_contact_name");
+
+                    b.Property<string>("EmergencyContactPhone")
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)")
+                        .HasColumnName("emergency_contact_phone");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)")
+                        .HasColumnName("first_name");
+
+                    b.Property<string>("Gender")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)")
+                        .HasColumnName("gender");
+
+                    b.Property<string>("LastName")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)")
+                        .HasColumnName("last_name");
+
+                    b.Property<string>("Mrn")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)")
+                        .HasColumnName("mrn");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)")
+                        .HasDefaultValue("active")
+                        .HasColumnName("status");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Mrn")
+                        .IsUnique();
+
+                    b.ToTable("patients", (string)null);
+                });
+
+            modelBuilder.Entity("ReconciliationAlert", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("id")
+                        .HasDefaultValueSql("gen_random_uuid()");
+
+                    b.Property<string>("CheckType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("check_type");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at")
+                        .HasDefaultValueSql("NOW()");
+
+                    b.Property<string>("Details")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("details");
+
+                    b.Property<Guid?>("EncounterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("encounter_id");
+
+                    b.Property<Guid?>("PatientId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("patient_id");
+
+                    b.Property<DateTimeOffset?>("ResolvedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("resolved_at");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EncounterId");
+
+                    b.HasIndex("PatientId");
+
+                    b.HasIndex("CheckType", "EncounterId")
+                        .HasFilter("resolved_at IS NULL");
+
+                    b.ToTable("reconciliation_alerts", null, t =>
+                        {
+                            t.HasCheckConstraint("chk_reconciliation_alerts_check_type", "check_type IN ('UNACKNOWLEDGED_CRITICAL_ALERT', 'PENDING_ORDER_NO_RESULT', 'ACTIVE_INPATIENT_NO_OBSERVATION')");
+                        });
+                });
+
+            modelBuilder.Entity("ClinicalAlert", b =>
+                {
+                    b.HasOne("Encounter", "Encounter")
+                        .WithMany("Alerts")
+                        .HasForeignKey("EncounterId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Encounter");
+                });
+
+            modelBuilder.Entity("Encounter", b =>
+                {
+                    b.HasOne("Patient", "Patient")
+                        .WithMany("Encounters")
+                        .HasForeignKey("PatientId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Patient");
+                });
+
+            modelBuilder.Entity("News2Score", b =>
+                {
+                    b.HasOne("Encounter", "Encounter")
+                        .WithMany()
+                        .HasForeignKey("EncounterId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Encounter");
+                });
+
+            modelBuilder.Entity("Observation", b =>
+                {
+                    b.HasOne("Encounter", "Encounter")
+                        .WithMany("Observations")
+                        .HasForeignKey("EncounterId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Encounter");
+                });
+
+            modelBuilder.Entity("Order", b =>
+                {
+                    b.HasOne("Encounter", "Encounter")
+                        .WithMany("Orders")
+                        .HasForeignKey("EncounterId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Encounter");
+                });
+
+            modelBuilder.Entity("ReconciliationAlert", b =>
+                {
+                    b.HasOne("Encounter", "Encounter")
+                        .WithMany()
+                        .HasForeignKey("EncounterId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("Patient", "Patient")
+                        .WithMany()
+                        .HasForeignKey("PatientId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Encounter");
+
+                    b.Navigation("Patient");
+                });
+
+            modelBuilder.Entity("Encounter", b =>
+                {
+                    b.Navigation("Alerts");
+
+                    b.Navigation("Observations");
+
+                    b.Navigation("Orders");
+                });
+
+            modelBuilder.Entity("Patient", b =>
+                {
+                    b.Navigation("Encounters");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

VigilCareClinicalAPI/Migrations/20260618124632_AddSuppressionWindowMinutes.cs

@@ -0,0 +1,28 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace VigilCareClinicalAPI.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddSuppressionWindowMinutes : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "suppression_window_minutes",
+                table: "alert_thresholds",
+                type: "integer",
+                nullable: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "suppression_window_minutes",
+                table: "alert_thresholds");
+        }
+    }
+}

VigilCareClinicalAPI/Migrations/AppDbContextModelSnapshot.cs

@@ -55,6 +55,10 @@ namespace VigilCareClinicalAPI.Migrations
                         .HasColumnType("character varying(50)")
                         .HasColumnName("observation_code");
 
+                    b.Property<int?>("SuppressionWindowMinutes")
+                        .HasColumnType("integer")
+                        .HasColumnName("suppression_window_minutes");
+
                     b.Property<string>("Unit")
                         .IsRequired()
                         .HasMaxLength(20)

VigilCareClinicalAPI/Models/Records/Trend/TrendHistoryEntry.cs

@@ -0,0 +1 @@
+public record TrendHistoryEntry(decimal Value, DateTimeOffset RecordedAt);

VigilCareClinicalAPI/Models/Records/Trend/TrendObservationEvent.cs

@@ -0,0 +1,6 @@
+public record TrendObservationEvent(
+    Guid EncounterId,
+    Guid PatientId,
+    string ObservationCode,
+    decimal Value,
+    DateTimeOffset RecordedAt);

VigilCareClinicalAPI/Models/Records/Trend/TrendResult.cs

@@ -0,0 +1,5 @@
+public record TrendResult(
+    TrendOutcome Outcome,
+    string? ObservationCode = null,
+    decimal? RatePerMinute = null,
+    bool AlertCreated = false);

VigilCareClinicalAPI/News2/News2Detector.cs

@@ -153,6 +153,16 @@ public class News2Detector
         int totalScore, string riskLevel, int[] paramScores,
         CancellationToken ct)
     {
+        if (alertType == AlertType.News2Warning)
+        {
+            var suppression = _services.GetRequiredService<IAlertSuppressionService>();
+            if (await suppression.IsSuppressedAsync(encounterId, alertType, ct))
+            {
+                _logger.LogDebug("NEWS2_WARNING suppressed for encounter {Id}", encounterId);
+                return false;
+            }
+        }
+
         using var scope = _services.CreateScope();
         var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
 

VigilCareClinicalAPI/Observability/Metrics/ClinicalMetrics.cs

@@ -36,6 +36,16 @@ public sealed class ClinicalMetrics
         "escalations_total",
         "Total alert escalations processed through the DLQ escalation path.");
 
+    public readonly Counter TrendAlertsTotal = Metrics.CreateCounter(
+        "trend_alerts_total",
+        "Total RAPID_DETERIORATION alerts generated, labeled by observation code.",
+        labelNames: new[] { "observation_code" });
+
+    public readonly Counter AlertSuppressionsTotal = Metrics.CreateCounter(
+        "alert_suppressions_total",
+        "Total alert suppression windows set after acknowledgment.",
+        labelNames: new[] { "alert_type" });
+
     // --- Histograms ---
 
     // Measures the full ingest transaction: Redis cache lookup + alert evaluation +
@@ -53,6 +63,14 @@ public sealed class ClinicalMetrics
         "news2_scoring_duration_seconds",
         "Time to compute a NEWS2 score from Redis state.",
         new HistogramConfiguration
+        {
+            Buckets = new[] { 0.001, 0.005, 0.01, 0.025, 0.05, 0.1 }
+        });   
+        
+    public readonly Histogram TrendAnalysisDuration = Metrics.CreateHistogram(
+        "trend_analysis_duration_seconds",
+        "Time to evaluate trend for one observation.",
+        new HistogramConfiguration
         {
             Buckets = new[] { 0.001, 0.005, 0.01, 0.025, 0.05, 0.1 }
         });

VigilCareClinicalAPI/Program.cs

@@ -65,6 +65,12 @@ try
     builder.Services.Configure<DataLakeOptions>(
     builder.Configuration.GetSection(DataLakeOptions.Section));
 
+    builder.Services.Configure<TrendDetectionOptions>(
+    builder.Configuration.GetSection(TrendDetectionOptions.SectionName));
+
+    builder.Services.Configure<SuppressionOptions>(
+    builder.Configuration.GetSection(SuppressionOptions.SectionName));
+
     builder.Services.AddScoped<IPatientService, PatientService>();
     builder.Services.AddScoped<IEncounterService, EncounterService>();
     builder.Services.AddScoped<IAlertThresholdService, AlertThresholdService>();
@@ -81,6 +87,8 @@ try
     builder.Services.AddScoped<ReconciliationPublisher>();    
     builder.Services.AddScoped<WarningEvaluator>();
     builder.Services.AddScoped<News2Detector>();
+    builder.Services.AddScoped<TrendDetector>();
+    builder.Services.AddSingleton<IAlertSuppressionService, AlertSuppressionService>();
 
     builder.Services.AddHostedService<ThresholdCacheLoader>();
     builder.Services.AddHostedService<KafkaTopicProvisioner>();
@@ -100,6 +108,7 @@ try
     builder.Services.AddHostedService<DataLakeWriterService>();
     builder.Services.AddHostedService<WarningAlertService>();
     builder.Services.AddHostedService<News2ScoringService>();
+    builder.Services.AddHostedService<TrendAnalyzerService>();
 
 
     builder.Services.AddControllers()

VigilCareClinicalAPI/Services/AlertService.cs

@@ -1,11 +1,17 @@
 using System.Text.Json;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Options;
 
 public class AlertService : IAlertService
 {
     private readonly AppDbContext _db;
+    private readonly IServiceProvider _services;
 
-    public AlertService(AppDbContext db) => _db = db;
+    public AlertService(AppDbContext db, IServiceProvider services)
+    {
+        _db = db;
+        _services = services;
+    }
 
     public async Task<PagedResult<ClinicalAlert>> ListByEncounterAsync(
         Guid encounterId, AlertStatus? status, int page, int pageSize)
@@ -100,10 +106,42 @@ public class AlertService : IAlertService
             CreatedAt = DateTimeOffset.UtcNow
         });
 
+        if (alert.AlertType.IsSuppressible())
+        {
+            var suppression = _services.GetRequiredService<IAlertSuppressionService>();
+            var options = _services.GetRequiredService<IOptions<SuppressionOptions>>().Value;
+            var windowMinutes = await ResolveSuppressionWindowMinutesAsync(
+                alert.AlertType, options.DefaultWindowMinutes);
+
+            await suppression.SetSuppressionAsync(
+                alert.EncounterId,
+                alert.AlertType,
+                TimeSpan.FromMinutes(windowMinutes));
+        }
+
         await _db.SaveChangesAsync();
         return alert;
     }
 
+    private async Task<int> ResolveSuppressionWindowMinutesAsync(
+        AlertType alertType, int defaultWindowMinutes)
+    {
+        if (alertType == AlertType.News2Warning)
+            return defaultWindowMinutes;
+
+        var observationCode = alertType.ObservationCodeForWarning();
+        if (observationCode is null)
+            return defaultWindowMinutes;
+
+        var overrideMinutes = await _db.AlertThresholds
+            .AsNoTracking()
+            .Where(t => t.ObservationCode == observationCode)
+            .Select(t => t.SuppressionWindowMinutes)
+            .FirstOrDefaultAsync();
+
+        return overrideMinutes ?? defaultWindowMinutes;
+    }
+
     public async Task<ClinicalAlert> ResolveAsync(Guid id)
     {
         var alert = await _db.ClinicalAlerts.FindAsync(id);

VigilCareClinicalAPI/Services/AlertSuppressionService.cs

@@ -0,0 +1,31 @@
+using StackExchange.Redis;
+
+public class AlertSuppressionService : IAlertSuppressionService
+{
+    private readonly IConnectionMultiplexer _redis;
+    private readonly ClinicalMetrics _metrics;
+
+    public AlertSuppressionService(IConnectionMultiplexer redis, ClinicalMetrics metrics)
+    {
+        _redis = redis;
+        _metrics = metrics;
+    }
+
+    public static string SuppressionKey(Guid encounterId, AlertType alertType) =>
+        $"suppress:{encounterId}:{alertType.ToDbString()}";
+
+    public async Task SetSuppressionAsync(
+        Guid encounterId, AlertType alertType, TimeSpan ttl, CancellationToken ct = default)
+    {
+        var cache = _redis.GetDatabase();
+        await cache.StringSetAsync(SuppressionKey(encounterId, alertType), "1", ttl);
+        _metrics.AlertSuppressionsTotal.WithLabels(alertType.ToDbString()).Inc();
+    }
+
+    public async Task<bool> IsSuppressedAsync(
+        Guid encounterId, AlertType alertType, CancellationToken ct = default)
+    {
+        var cache = _redis.GetDatabase();
+        return await cache.KeyExistsAsync(SuppressionKey(encounterId, alertType));
+    }
+}

VigilCareClinicalAPI/Services/Interfaces/IAlertSuppressionService.cs

@@ -0,0 +1,5 @@
+public interface IAlertSuppressionService
+{
+    Task SetSuppressionAsync(Guid encounterId, AlertType alertType, TimeSpan ttl, CancellationToken ct = default);
+    Task<bool> IsSuppressedAsync(Guid encounterId, AlertType alertType, CancellationToken ct = default);
+}

VigilCareClinicalAPI/Services/WarningEvaluator.cs

@@ -35,6 +35,15 @@ public class WarningEvaluator
         // critical alerts are created synchronously by the ingest path.
         if (IsCriticalBreach(value, threshold)) return false;
 
+        var alertType = AlertTypeExtensions.WarningFor(observationCode);
+        var suppression = _services.GetRequiredService<IAlertSuppressionService>();
+        if (await suppression.IsSuppressedAsync(encounterId, alertType, ct))
+        {
+            _logger.LogDebug(
+                "Warning alert suppressed for encounter {Id} type {Type}", encounterId, alertType);
+            return false;
+        }
+
         return await TryCreateWarningAlertAsync(
             observationId, encounterId, patientId, observationCode, value, threshold, ct);
     }

VigilCareClinicalAPI/Trend/TrendCalculator.cs

@@ -0,0 +1,62 @@
+using StackExchange.Redis;
+
+public static class TrendCalculator
+{
+    // NEWS2-relevant codes that support trend detection.
+    public static readonly IReadOnlyList<string> TrendCodes = new[]
+    {
+        "HEART_RATE", "RESP_RATE", "SYSTOLIC_BP", "TEMP_C", "SPO2"
+    };
+
+    public static bool IsTrendCode(string observationCode) =>
+        TrendCodes.Contains(observationCode);
+
+    public static string HistoryKey(Guid encounterId, string code) =>
+        $"trend:{encounterId}:{code}";
+
+    public static RedisKey[] AllHistoryKeys(Guid encounterId) =>
+        TrendCodes.Select(c => (RedisKey)HistoryKey(encounterId, c)).ToArray();
+
+    /// <summary>
+    /// Computes rate of change (units per minute) between the oldest and newest
+    /// entries within the window. Returns null if fewer than 2 entries or window exceeded.
+    /// </summary>
+    public static decimal? ComputeRatePerMinute(
+        IReadOnlyList<TrendHistoryEntry> entries,
+        int windowMinutes)
+    {
+        if (entries.Count < 2) return null;
+
+        var newest = entries[^1];
+        var oldest = entries[0];
+
+        var deltaMinutes = (newest.RecordedAt - oldest.RecordedAt).TotalMinutes;
+        if (deltaMinutes <= 0 || deltaMinutes > windowMinutes) return null;
+
+        return (newest.Value - oldest.Value) / (decimal)deltaMinutes;
+    }
+
+    /// <summary>
+    /// Returns true if the rate exceeds the configured threshold.
+    /// For SPO2 and SYSTOLIC_BP, checks negative rate (decline) as clinically significant.
+    /// </summary>
+    public static bool ExceedsThreshold(
+        string observationCode,
+        decimal ratePerMinute,
+        decimal thresholdPerMinute) =>
+        observationCode switch
+        {
+            "SPO2" or "SYSTOLIC_BP" => ratePerMinute <= -thresholdPerMinute,
+            _ => ratePerMinute >= thresholdPerMinute
+        };
+
+    public static string DescribeTrend(
+        string observationCode, decimal ratePerMinute, decimal currentValue) =>
+        observationCode switch
+        {
+            "SPO2" or "SYSTOLIC_BP" =>
+                $"Rapid decline: {observationCode} falling at {Math.Abs(ratePerMinute):F2}/min (current {currentValue})",
+            _ =>
+                $"Rapid rise: {observationCode} rising at {ratePerMinute:F2}/min (current {currentValue})"
+        };
+}

VigilCareClinicalAPI/Trend/TrendDetector.cs

@@ -0,0 +1,152 @@
+using System.Text.Json;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Options;
+using Prometheus;
+using StackExchange.Redis;
+
+public class TrendDetector
+{
+    private readonly IConnectionMultiplexer _redis;
+    private readonly IServiceProvider _services;
+    private readonly TrendDetectionOptions _options;
+    private readonly ClinicalMetrics _metrics;
+    private readonly ILogger<TrendDetector> _logger;
+
+    public TrendDetector(
+        ILogger<TrendDetector> logger, 
+        ClinicalMetrics metrics,
+        IServiceProvider services, 
+        IConnectionMultiplexer redis,
+        IOptions<TrendDetectionOptions> options)
+    {
+        _logger = logger;
+        _metrics = metrics;
+        _services = services;
+        _redis = redis;
+        _options = options.Value;
+    }
+
+    public async Task<TrendResult> ProcessObservationAsync(
+        Guid encounterId,
+        Guid patientId,
+        string observationCode,
+        decimal value,
+        DateTimeOffset recordedAt,
+        CancellationToken ct = default)
+    {
+        if (!TrendCalculator.IsTrendCode(observationCode))
+            return new TrendResult(TrendOutcome.NotTrendCode);
+
+        using var timer = _metrics.TrendAnalysisDuration.NewTimer();
+
+        var cache = _redis.GetDatabase();
+        var key = TrendCalculator.HistoryKey(encounterId, observationCode);
+
+        // Append new entry to history list
+        var entry = new TrendHistoryEntry(value, recordedAt);
+        var historyJson = await cache.StringGetAsync(key);
+        var history = historyJson.HasValue
+            ? JsonSerializer.Deserialize<List<TrendHistoryEntry>>(historyJson!) ?? new()
+            : new List<TrendHistoryEntry>();
+
+        history.Add(entry);
+
+        // Trim to max entries and evict entries outside window
+        var cutoff = recordedAt.AddMinutes(-_options.WindowMinutes);
+        history = history
+            .Where(e => e.RecordedAt >= cutoff)
+            .TakeLast(_options.MaxHistoryEntries)
+            .ToList();
+
+        await cache.StringSetAsync(
+            key,
+            JsonSerializer.Serialize(history),
+            TimeSpan.FromSeconds(_options.HistoryTtlSeconds));
+
+        if (history.Count < 2)
+            return new TrendResult(TrendOutcome.InsufficientHistory, observationCode);
+
+        var rate = TrendCalculator.ComputeRatePerMinute(history, _options.WindowMinutes);
+        if (rate is null)
+            return new TrendResult(TrendOutcome.InsufficientHistory, observationCode);
+
+        if (!_options.RateThresholdsPerMinute.TryGetValue(observationCode, out var threshold))
+            return new TrendResult(TrendOutcome.Stable, observationCode, rate);
+
+        if (!TrendCalculator.ExceedsThreshold(observationCode, rate.Value, threshold))
+            return new TrendResult(TrendOutcome.Stable, observationCode, rate);
+
+        var details = TrendCalculator.DescribeTrend(observationCode, rate.Value, value);
+        var created = await TryCreateAlertAsync(
+            encounterId, patientId, observationCode, details, rate.Value, ct);
+
+        return new TrendResult(
+            created ? TrendOutcome.RapidDeterioration : TrendOutcome.AlertAlreadyOpen,
+            observationCode, rate, created);
+    }
+
+    private async Task<bool> TryCreateAlertAsync(
+        Guid encounterId, Guid patientId,
+        string observationCode, string details, decimal ratePerMinute,
+        CancellationToken ct)
+    {
+        using var scope = _services.CreateScope();
+        var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
+
+        await using var tx = await db.Database.BeginTransactionAsync(ct);
+
+        var alertId = Guid.NewGuid();
+        var triggeredAt = DateTimeOffset.UtcNow;
+        var fullDetails = $"{details} — velocity {ratePerMinute:F2}/min over {_options.WindowMinutes}min window.";
+
+        var affected = await db.Database.ExecuteSqlInterpolatedAsync($"""
+            INSERT INTO clinical_alerts
+                (id, encounter_id, patient_id, alert_type, severity, details, status, triggered_at)
+            SELECT {alertId}, {encounterId}, {patientId},
+                   'RAPID_DETERIORATION', 'WARNING', {fullDetails}, 'OPEN', {triggeredAt}
+            WHERE NOT EXISTS (
+                SELECT 1 FROM clinical_alerts
+                WHERE  encounter_id = {encounterId}
+                  AND  alert_type   = 'RAPID_DETERIORATION'
+                  AND  details      LIKE {$"%{observationCode}%"}
+                  AND  status       IN ('OPEN', 'ESCALATED')
+            )
+            """, ct);
+
+        if (affected == 0)
+        {
+            await tx.RollbackAsync(ct);
+            return false;
+        }
+
+        db.OutboxEvents.Add(new OutboxEvent
+        {
+            Id = Guid.NewGuid(),
+            Topic = "alert.generated",
+            Payload = JsonSerializer.Serialize(new
+            {
+                alertId,
+                encounterId,
+                patientId,
+                alertType = "RAPID_DETERIORATION",
+                severity = "Warning",
+                details = fullDetails,
+                triggeredAt,
+                observationCode,
+                ratePerMinute,
+                partitionKey = encounterId.ToString()
+            }),
+            PartitionKey = encounterId.ToString(),
+            CreatedAt = DateTimeOffset.UtcNow
+        });
+
+        await db.SaveChangesAsync(ct);
+        await tx.CommitAsync(ct);
+
+        _metrics.TrendAlertsTotal.WithLabels(observationCode).Inc();
+        _metrics.ClinicalAlertsTotal
+            .WithLabels("RAPID_DETERIORATION", "Warning").Inc();
+
+        return true;
+    }
+}

VigilCareClinicalAPI/appsettings.json

@@ -78,5 +78,20 @@
   "DataLake": {
     "FlushCount": 1000,
     "FlushIntervalSeconds": 300
+  },
+  "TrendDetection": {
+    "WindowMinutes": 30,
+    "MaxHistoryEntries": 10,
+    "HistoryTtlSeconds": 7200,
+    "RateThresholdsPerMinute": {
+      "HEART_RATE": 0.5,
+      "RESP_RATE": 0.3,
+      "SYSTOLIC_BP": 1.0,
+      "TEMP_C": 0.05,
+      "SPO2": 0.2
+    }
+  },
+  "AlertSuppression": {
+    "DefaultWindowMinutes": 30
   }
 }