diff --git a/.github/agents/copilot-instructions.md b/.github/agents/copilot-instructions.md
index d5b3478..fe8cf22 100644
--- a/.github/agents/copilot-instructions.md
+++ b/.github/agents/copilot-instructions.md
@@ -22,6 +22,7 @@ cargo test [ONLY COMMANDS FOR ACTIVE TECHNOLOGIES][ONLY COMMANDS FOR ACTIVE TECH
 Rust 1.75+ (edition 2021, per Cargo.toml): Follow standard conventions
 
 ## Recent Changes
+- 003-sd-api-v2-migration: Added [if applicable, e.g., PostgreSQL, CoreData, files or N/A]
 
 - 001-project-documentation: Added Rust 1.75+ (edition 2021, per Cargo.toml) + axum (0.6), tokio (1.28), serde (1.0), tracing (0.1), reqwest (0.11)
 
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index eef7c44..a284523 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -18,12 +18,16 @@ jobs:
     steps:
     - uses: actions/checkout@v4
 
-# Temporarily disabled linting and formatting checks, to be re-enabled later.
-#    - name: Check formatting
-#      run: make fmt-check
-#
-#    - name: Run linter
-#      run: make lint
+    - name: Install Rust
+      uses: dtolnay/rust-toolchain@stable
+      with:
+        components: rustfmt, clippy
+
+    - name: Check formatting
+      run: make fmt-check
+
+    - name: Run linter
+      run: make lint
 
     - name: Run tests
       run: make test
@@ -37,6 +41,5 @@ jobs:
     steps:
     - uses: actions/checkout@v4
 
-
     - name: Run tests with coverage
       run: make coverage-check
diff --git a/.gitignore b/.gitignore
index 93b1dcc..7cfbd1e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -28,3 +28,6 @@ docs/
 coverage/
 tarpaulin-report.html
 cobertura.xml
+
+# ai assistant files
+skills
\ No newline at end of file
diff --git a/Cargo.toml b/Cargo.toml
index 6682e86..9a43c57 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -18,6 +18,7 @@ path="src/bin/reporter.rs"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+anyhow = "~1.0"
 axum = { version="~0.6" }
 axum-macros = { version="~0.3" }
 chrono = "~0.4"
@@ -45,15 +46,12 @@ uuid = { version = "~1.3", features = ["v4", "fast-rng"] }
 
 [dev-dependencies]
 mockito = "~1.0"
+serial_test = "3.3.1"
 tempfile = "~3.5"
 tokio-test = "*"
 tower = { version = "0.4", features = ["util"] }
 hyper = { version = "0.14", features = ["full"] }
 
-[build-dependencies]
-schemars = "~0.8"
-serde = { version = "~1.0", features = ["derive"] }
-serde_json = "~1.0"
 
 [target.'cfg(all(target_env = "musl", target_pointer_width = "64"))'.dependencies.jemallocator]
 version = "0.3"
diff --git a/Makefile b/Makefile
index 44f6012..fb91762 100644
--- a/Makefile
+++ b/Makefile
@@ -110,7 +110,7 @@ lint-fix:
 # ============================================================================
 
 ## Build mdbook documentation
-doc:
+doc: doc-schema
 	mdbook build doc/
 
 ## Serve documentation locally with live reload
@@ -129,6 +129,10 @@ doc-api:
 doc-api-open:
 	cargo doc --no-deps --open
 
+## Generate JSON schema for configuration
+doc-schema:
+	cargo test --lib -- generate_config_schema --ignored --nocapture
+
 ## Clean generated documentation
 doc-clean:
 	rm -rf docs/*
@@ -205,6 +209,7 @@ help:
 	@echo "    doc-open       - Build and open documentation in browser"
 	@echo "    doc-api        - Generate Rust API documentation"
 	@echo "    doc-api-open   - Generate and open Rust API docs in browser"
+	@echo "    doc-schema     - Generate JSON schema for configuration"
 	@echo "    doc-clean      - Clean generated documentation"
 	@echo ""
 	@echo "  Utilities:"
diff --git a/README.md b/README.md
index d711ab4..3ed1d75 100644
--- a/README.md
+++ b/README.md
@@ -73,7 +73,7 @@ mdbook serve doc/
 ### Running Tests
 
 ```bash
-# Run all tests
+# Run all unit tests
 cargo test
 
 # Run tests with output
@@ -86,6 +86,31 @@ cargo test common::tests
 cargo test -- --test-threads=4
 ```
 
+### E2E Integration Tests
+
+End-to-end tests validate the complete pipeline using real Docker containers (go-carbon + carbonapi).
+
+#### Prerequisites
+- Docker installed and running
+- Ports available: 2003, 8080, 3005, 9999
+
+#### Running E2E Tests
+
+```bash
+# Run E2E tests (Docker containers are managed automatically)
+cargo test --test integration_e2e_reporter -- --ignored --nocapture
+```
+
+The E2E test validates 4 scenarios:
+| Scenario | Expected Weight | Description |
+|----------|-----------------|-------------|
+| healthy | 0 | All metrics within thresholds |
+| degraded_slow | 1 | API response time > 1200ms |
+| degraded_errors | 1 | Success rate < 65% |
+| outage | 2 | 100% API failures |
+
+For details, see [Testing Guide](doc/testing.md).
+
 ### Test Coverage
 
 ```bash
@@ -99,8 +124,6 @@ cargo tarpaulin --out Html
 open tarpaulin-report.html
 ```
 
-For detailed testing documentation, see [Testing Guide](doc/testing.md).
-
 ### JSON Schema for Configuration
 
 A JSON Schema for configuration validation is auto-generated during build:
diff --git a/build.rs b/build.rs
deleted file mode 100644
index 00a939f..0000000
--- a/build.rs
+++ /dev/null
@@ -1,163 +0,0 @@
-// Build script to generate JSON schema for configuration
-
-use schemars::{schema_for, JsonSchema};
-use serde::Deserialize;
-use std::collections::HashMap;
-use std::fs;
-use std::path::Path;
-
-// Re-define the Config struct with JsonSchema derive
-// This is a simplified version matching the actual Config struct
-
-/// Configuration structure
-#[derive(Clone, Debug, Deserialize, JsonSchema)]
-pub struct Config {
-    /// TSDB datasource connection
-    pub datasource: Datasource,
-    /// HTTP server binding configuration
-    pub server: ServerConf,
-    /// Metric query templates
-    pub metric_templates: Option<HashMap<String, BinaryMetricRawDef>>,
-    /// Environment definitions
-    pub environments: Vec<EnvironmentDef>,
-    /// Flag metric definitions
-    pub flag_metrics: Vec<FlagMetricDef>,
-    /// Health metric definitions per service
-    pub health_metrics: HashMap<String, ServiceHealthDef>,
-    /// Status dashboard connection (optional)
-    pub status_dashboard: Option<StatusDashboardConfig>,
-}
-
-/// TSDB Datasource connection
-#[derive(Clone, Debug, Deserialize, JsonSchema)]
-pub struct Datasource {
-    /// TSDB URL (e.g., http://localhost:8080)
-    pub url: String,
-    /// Query timeout in seconds (default: 10)
-    #[serde(default = "default_timeout")]
-    pub timeout: u16,
-}
-
-/// Server binding configuration
-#[derive(Clone, Debug, Deserialize, JsonSchema)]
-pub struct ServerConf {
-    /// IP address to bind to (default: 0.0.0.0)
-    #[serde(default = "default_address")]
-    pub address: String,
-    /// Port to bind to (default: 3000)
-    #[serde(default = "default_port")]
-    pub port: u16,
-}
-
-/// Binary metric raw definition (template)
-#[derive(Clone, Debug, Deserialize, JsonSchema)]
-pub struct BinaryMetricRawDef {
-    /// TSDB query template with variable substitution
-    pub query: String,
-    /// Comparison operator (lt, gt, eq)
-    pub op: String,
-    /// Threshold value for comparison
-    pub threshold: f64,
-}
-
-/// Environment definition
-#[derive(Clone, Debug, Deserialize, JsonSchema)]
-pub struct EnvironmentDef {
-    /// Environment name (e.g., production, staging)
-    pub name: String,
-}
-
-/// Flag metric definition
-#[derive(Clone, Debug, Deserialize, JsonSchema)]
-pub struct FlagMetricDef {
-    /// Metric name
-    pub name: String,
-    /// Service name
-    pub service: String,
-    /// Template reference
-    pub template: TemplateDef,
-    /// Environment-specific overrides
-    pub environments: Vec<EnvironmentOverride>,
-}
-
-/// Template reference
-#[derive(Clone, Debug, Deserialize, JsonSchema)]
-pub struct TemplateDef {
-    /// Template name (references metric_templates key)
-    pub name: String,
-}
-
-/// Environment-specific override
-#[derive(Clone, Debug, Deserialize, JsonSchema)]
-pub struct EnvironmentOverride {
-    /// Environment name
-    pub name: String,
-    /// Overridden threshold (optional)
-    pub threshold: Option<f64>,
-}
-
-/// Service health definition
-#[derive(Clone, Debug, Deserialize, JsonSchema)]
-pub struct ServiceHealthDef {
-    /// Service name
-    pub service: String,
-    /// Component display name
-    pub component_name: Option<String>,
-    /// Category (e.g., compute, network, storage)
-    pub category: String,
-    /// List of flag metric names to evaluate
-    pub metrics: Vec<String>,
-    /// Boolean expressions with weights
-    pub expressions: Vec<ExpressionDef>,
-}
-
-/// Health expression definition
-#[derive(Clone, Debug, Deserialize, JsonSchema)]
-pub struct ExpressionDef {
-    /// Boolean expression (e.g., "api_slow || api_error_rate_high")
-    pub expression: String,
-    /// Weight: 0=healthy, 1=degraded, 2=outage
-    pub weight: u8,
-}
-
-/// Status Dashboard configuration
-#[derive(Clone, Debug, Deserialize, JsonSchema)]
-pub struct StatusDashboardConfig {
-    /// Status dashboard URL
-    pub url: String,
-    /// JWT token signature secret (optional)
-    pub secret: Option<String>,
-}
-
-fn default_address() -> String {
-    "0.0.0.0".to_string()
-}
-
-fn default_port() -> u16 {
-    3000
-}
-
-fn default_timeout() -> u16 {
-    10
-}
-
-fn main() {
-    println!("cargo:rerun-if-changed=src/config.rs");
-    println!("cargo:rerun-if-changed=src/types.rs");
-
-    // Generate JSON schema
-    let schema = schema_for!(Config);
-    let schema_json = serde_json::to_string_pretty(&schema).expect("Failed to serialize schema");
-
-    // Create doc/schemas directory if it doesn't exist
-    let schemas_dir = Path::new("doc/schemas");
-    if !schemas_dir.exists() {
-        fs::create_dir_all(schemas_dir).expect("Failed to create doc/schemas directory");
-    }
-
-    // Write schema to file
-    let schema_path = schemas_dir.join("config-schema.json");
-    fs::write(&schema_path, schema_json).expect("Failed to write config-schema.json");
-
-    println!("Generated JSON schema at: {:?}", schema_path);
-}
diff --git a/doc/config.md b/doc/config.md
index 6456058..4fc5a18 100644
--- a/doc/config.md
+++ b/doc/config.md
@@ -89,7 +89,33 @@ This section is providing capability to describe query templates to be later ref
 
 ## status_dashboard
 
-Configures URL and jwt secret for communication with the status dashboard
+Configures URL and JWT secret for communication with the status dashboard.
+
+```yaml
+status_dashboard:
+  url: "https://status-dashboard.example.com"
+  secret: "your-jwt-secret"
+```
+
+| Property | Type   | Required | Default | Description                           |
+|----------|--------|----------|---------|---------------------------------------|
+| `url`    | string | Yes      | -       | Status Dashboard API URL              |
+| `secret` | string | No       | -       | JWT signing secret for authentication |
+
+## health_query
+
+Configures the time window for health metric queries.
+
+```yaml
+health_query:
+  query_from: "-5min"
+  query_to: "-2min"
+```
+
+| Property     | Type   | Required | Default | Description                                                         |
+|--------------|--------|----------|---------|---------------------------------------------------------------------|
+| `query_from` | string | No       | `-5min` | Start time offset for health metric queries (e.g., "-10min", "-1h") |
+| `query_to`   | string | No       | `-2min` | End time offset for health metric queries (e.g., "-1min", "-30s")   |
 
 ## flag_metrics
 
diff --git a/doc/configuration/schema.md b/doc/configuration/schema.md
index cd7f9f0..c2a45de 100644
--- a/doc/configuration/schema.md
+++ b/doc/configuration/schema.md
@@ -52,8 +52,8 @@ TSDB connection configuration.
 
 | Property | Type | Required | Default | Description |
 |----------|------|----------|---------|-------------|
-| `url` | string | Yes | - | TSDB URL (e.g., `http://graphite:8080`) |
-| `timeout` | integer | No | `10` | Query timeout in seconds |
+| `url` | string | Yes | -       | TSDB URL (e.g., `http://graphite:8080`) |
+| `timeout` | integer | No | `2`     | Query timeout in seconds |
 
 ```yaml
 datasource:
diff --git a/doc/modules/overview.md b/doc/modules/overview.md
index 378fc4d..ddd708b 100644
--- a/doc/modules/overview.md
+++ b/doc/modules/overview.md
@@ -6,19 +6,20 @@ This document provides a high-level overview of the metrics-processor crate modu
 
 | Module | Primary Responsibility | Key Types | Dependencies | Used By |
 |--------|----------------------|-----------|--------------|---------|
-| `lib` | Crate entry point | - | `api`, `common`, `config`, `graphite`, `types` | External consumers |
+| `lib` | Crate entry point | - | `api`, `common`, `config`, `graphite`, `sd`, `types` | External consumers |
 | `api` | HTTP API routing | - | `api::v1` | `main` binary |
 | `api::v1` | V1 REST endpoints | `HealthQuery`, `ServiceHealthResponse` | `common`, `types` | `api` |
 | `config` | Configuration parsing | `Config`, `Datasource`, `ServerConf` | `types` | `types`, `main` |
 | `types` | Core data structures | `AppState`, `FlagMetric`, `ServiceHealthDef` | `config` | All modules |
 | `graphite` | Graphite TSDB interface | `GraphiteData`, `Metric`, `RenderRequest` | `common`, `types` | `common`, `api::v1` |
 | `common` | Shared utilities | - | `types`, `graphite` | `api::v1`, `graphite` |
+| `sd` | Status Dashboard API | `IncidentData`, `ComponentCache`, `StatusDashboardComponent` | `anyhow`, `hmac`, `jwt` | `reporter` binary |
 
 ## Architecture Diagram
 
 ```
 ┌─────────────────────────────────────────────────────────────┐
-│                       main binary                           │
+│                    convertor binary                         │
 └─────────────────────────────────────────────────────────────┘
                               │
                               ▼
@@ -47,6 +48,23 @@ This document provides a high-level overview of the metrics-processor crate modu
                      │   HTTP Server   │
                      │     (Axum)      │
                      └─────────────────┘
+
+┌─────────────────────────────────────────────────────────────┐
+│                     reporter binary                         │
+└─────────────────────────────────────────────────────────────┘
+                              │
+          ┌───────────────────┼───────────────────┐
+          ▼                   ▼                   ▼
+┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐
+│      config     │  │       sd        │  │   api::v1       │
+│  (Config load)  │  │ (Status Dash)   │  │  (Query health) │
+└─────────────────┘  └─────────────────┘  └─────────────────┘
+                              │
+                              ▼
+                     ┌─────────────────┐
+                     │ Status Dashboard│
+                     │   V2 API        │
+                     └─────────────────┘
 ```
 
 ## Module Summaries
diff --git a/doc/modules/sd.md b/doc/modules/sd.md
new file mode 100644
index 0000000..5227292
--- /dev/null
+++ b/doc/modules/sd.md
@@ -0,0 +1,231 @@
+# Status Dashboard Module (`sd`)
+
+The `sd` module provides all functionality for integrating with the Status Dashboard API, including component management, incident creation, cache operations, and authentication.
+
+## Module Location
+
+- **Source**: `src/sd.rs`
+- **Public export**: `cloudmon_metrics::sd`
+
+## Overview
+
+This module consolidates all Status Dashboard V2 API integration logic in one place, providing:
+
+- Component fetching and caching
+- Component ID resolution with subset attribute matching
+- Incident creation with static payloads
+- HMAC-JWT authentication
+
+## Data Structures
+
+### ComponentAttribute
+
+Key-value pair for identifying components:
+
+```rust
+#[derive(Clone, Deserialize, Serialize, Debug, PartialEq, Eq, Hash, Ord, PartialOrd)]
+pub struct ComponentAttribute {
+    pub name: String,
+    pub value: String,
+}
+```
+
+Derives `Ord` and `PartialOrd` for deterministic sorting in cache keys.
+
+### Component
+
+Component definition from configuration:
+
+```rust
+#[derive(Clone, Deserialize, Serialize, Debug)]
+pub struct Component {
+    pub name: String,
+    pub attributes: Vec<ComponentAttribute>,
+}
+```
+
+### StatusDashboardComponent
+
+API response from `GET /v2/components`:
+
+```rust
+#[derive(Clone, Deserialize, Serialize, Debug)]
+pub struct StatusDashboardComponent {
+    pub id: u32,
+    pub name: String,
+    #[serde(default)]
+    pub attributes: Vec<ComponentAttribute>,
+}
+```
+
+### IncidentData
+
+API request for `POST /v2/events`:
+
+```rust
+#[derive(Clone, Deserialize, Serialize, Debug)]
+pub struct IncidentData {
+    pub title: String,
+    pub description: String,
+    pub impact: u8,
+    pub components: Vec<u32>,
+    pub start_date: String,  // RFC3339 format
+    pub system: bool,
+    #[serde(rename = "type")]
+    pub incident_type: String,
+}
+```
+
+### ComponentCache
+
+Type alias for the component ID cache:
+
+```rust
+pub type ComponentCache = HashMap<(String, Vec<ComponentAttribute>), u32>;
+```
+
+Key: `(component_name, sorted_attributes)` → Value: `component_id`
+
+## Functions
+
+### Authentication
+
+#### `build_auth_headers`
+
+```rust
+pub fn build_auth_headers(secret: Option<&str>) -> HeaderMap
+```
+
+Generates HMAC-JWT authorization headers for Status Dashboard API.
+
+- Creates Bearer token using HMAC-SHA256 signing
+- Returns empty HeaderMap if no secret provided (optional auth)
+
+**Example**:
+```rust
+let headers = build_auth_headers(Some("my-secret"));
+// Headers contain: Authorization: Bearer eyJ...
+```
+
+### Component Management
+
+#### `fetch_components`
+
+```rust
+pub async fn fetch_components(
+    client: &reqwest::Client,
+    base_url: &str,
+    headers: &HeaderMap,
+) -> anyhow::Result<Vec<StatusDashboardComponent>>
+```
+
+Fetches all components from Status Dashboard API V2 (`GET /v2/components`).
+
+#### `build_component_id_cache`
+
+```rust
+pub fn build_component_id_cache(
+    components: Vec<StatusDashboardComponent>
+) -> ComponentCache
+```
+
+Builds component ID cache from fetched components. Sorts attributes for deterministic cache keys.
+
+#### `find_component_id`
+
+```rust
+pub fn find_component_id(
+    cache: &ComponentCache,
+    target: &Component
+) -> Option<u32>
+```
+
+Finds component ID in cache with **subset attribute matching**:
+- Config attributes must be a subset of cache attributes
+- Example: config `{region: "EU-DE"}` matches cache `{region: "EU-DE", category: "Storage"}`
+
+### Incident Management
+
+#### `build_incident_data`
+
+```rust
+pub fn build_incident_data(
+    component_id: u32,
+    impact: u8,
+    timestamp: i64
+) -> IncidentData
+```
+
+Builds incident data structure for V2 API:
+- **Static title**: "System incident from monitoring system"
+- **Static description**: "System-wide incident affecting one or multiple components. Created automatically."
+- **Timestamp**: RFC3339 format, minus 1 second from input
+- **system**: true (indicates auto-generated)
+
+#### `create_incident`
+
+```rust
+pub async fn create_incident(
+    client: &reqwest::Client,
+    base_url: &str,
+    headers: &HeaderMap,
+    incident_data: &IncidentData,
+) -> anyhow::Result<()>
+```
+
+Creates incident via Status Dashboard API V2 (`POST /v2/events`).
+
+## Usage Example
+
+```rust
+use cloudmon_metrics::sd::{
+    build_auth_headers, build_component_id_cache, build_incident_data,
+    create_incident, fetch_components, find_component_id,
+    Component, ComponentAttribute,
+};
+
+// Build auth headers
+let headers = build_auth_headers(config.secret.as_deref());
+
+// Fetch and cache components
+let components = fetch_components(&client, &url, &headers).await?;
+let cache = build_component_id_cache(components);
+
+// Find component ID
+let target = Component {
+    name: "Object Storage Service".to_string(),
+    attributes: vec![ComponentAttribute {
+        name: "region".to_string(),
+        value: "EU-DE".to_string(),
+    }],
+};
+let component_id = find_component_id(&cache, &target)?;
+
+// Create incident
+let incident = build_incident_data(component_id, 2, timestamp);
+create_incident(&client, &url, &headers, &incident).await?;
+```
+
+## Testing
+
+Integration tests are in `tests/integration_sd.rs`:
+
+```bash
+cargo test --test integration_sd
+```
+
+**Test coverage**:
+- `test_fetch_components_success` - API fetching
+- `test_build_component_id_cache` - Cache structure
+- `test_find_component_id_subset_matching` - Subset matching logic
+- `test_build_incident_data_structure` - Static payload generation
+- `test_timestamp_rfc3339_minus_one_second` - Timestamp handling
+- `test_create_incident_success` - API posting
+- `test_build_auth_headers` - JWT generation
+- Additional edge case tests
+
+## Related Documentation
+
+- [Reporter Overview](../reporter.md) - How reporter uses this module
+- [API Contracts](../../specs/003-sd-api-v2-migration/contracts/) - V2 API specifications
+- [Spec](../../specs/003-sd-api-v2-migration/spec.md) - Feature specification
diff --git a/doc/reporter.md b/doc/reporter.md
index 1864cf7..45e96d2 100644
--- a/doc/reporter.md
+++ b/doc/reporter.md
@@ -1,138 +1,179 @@
 # CloudMon Metrics Reporter
 
-The **reporter** component is a background service that polls the convertor API and sends health status updates to a status dashboard (e.g., Atlassian Statuspage).
+The **reporter** component is a background service that polls the convertor API and creates incidents in the Status Dashboard when health issues are detected.
 
 ## Overview
 
 The reporter acts as a bridge between the convertor's real-time health evaluation and external status dashboards:
-1. Polls convertor API at regular intervals
-2. Checks if service health has degraded (status > 0)
-3. Sends notifications to status dashboard
-4. Handles authentication and dashboard-specific protocols
+1. Initializes component ID cache from Status Dashboard API V2
+2. Polls convertor API at regular intervals (60 seconds)
+3. Checks if service health has degraded (impact > 0)
+4. Creates incidents via Status Dashboard API
+5. Handles HMAC-JWT authentication
 
 **Key Characteristics**:
 - **Background service**: Runs as daemon or scheduled job
+- **Component caching**: Maintains ID cache with automatic refresh on miss
+- **V2 API integration**: Uses Status Dashboard V2 endpoints for incident creation
 - **Stateless polling**: Queries convertor each interval
-- **Conditional notifications**: Only notifies when health degraded
-- **Dashboard integration**: Handles JWT authentication and API protocols
+- **Startup reliability**: 3 retry attempts with 60s delays for initial cache load
 
 ## Architecture
 
 ```
-┌──────────────────────────────────────────────┐
-│        Reporter (endless loop)               │
-│                                              │
-│  while true:                                 │
-│    sleep(poll_interval)                      │
-│    ┌───────────────────────────────────┐    │
-│    │ 1. Query Convertor API            │    │
-│    │    GET /v1/health for all services│    │
-│    └─────────────┬─────────────────────┘    │
-│                  ▼                           │
-│    ┌───────────────────────────────────┐    │
-│    │ 2. Check Health Status            │    │
-│    │    if status > 0: send update     │    │
-│    └─────────────┬─────────────────────┘    │
-│                  ▼                           │
-│    ┌───────────────────────────────────┐    │
-│    │ 3. Generate JWT Token             │    │
-│    │    HMAC-SHA256 with secret        │    │
-│    └─────────────┬─────────────────────┘    │
-│                  ▼                           │
-│    ┌───────────────────────────────────┐    │
-│    │ 4. Send to Status Dashboard       │    │
-│    │    POST to dashboard API          │    │
-│    └───────────────────────────────────┘    │
-│                                              │
-└──────────────────────────────────────────────┘
+┌──────────────────────────────────────────────────────────────┐
+│        Reporter (endless loop)                               │
+│                                                              │
+│  startup:                                                    │
+│    ┌───────────────────────────────────────┐                │
+│    │ 1. Fetch Components (3 retries)       │                │
+│    │    GET /v2/components                 │                │
+│    │    Build component ID cache           │                │
+│    └─────────────┬─────────────────────────┘                │
+│                  ▼                                           │
+│  while true:                                                 │
+│    sleep(60s)                                                │
+│    ┌───────────────────────────────────────┐                │
+│    │ 2. Query Convertor API                │                │
+│    │    GET /api/v1/health for all services│                │
+│    └─────────────┬─────────────────────────┘                │
+│                  ▼                                           │
+│    ┌───────────────────────────────────────┐                │
+│    │ 3. Check Health Status                │                │
+│    │    if impact > 0: create incident     │                │
+│    └─────────────┬─────────────────────────┘                │
+│                  ▼                                           │
+│    ┌───────────────────────────────────────┐                │
+│    │ 4. Resolve Component ID               │                │
+│    │    Lookup in cache (refresh if miss)  │                │
+│    └─────────────┬─────────────────────────┘                │
+│                  ▼                                           │
+│    ┌───────────────────────────────────────┐                │
+│    │ 5. Create Incident via V2 API         │                │
+│    │    POST /v2/events                    │                │
+│    └───────────────────────────────────────┘                │
+│                                                              │
+└──────────────────────────────────────────────────────────────┘
 ```
 
 ## Processing Flow
 
-### 1. Polling Loop
+### 1. Component Cache Initialization
 
-The reporter runs an infinite loop:
+At startup, the reporter fetches all components and builds an ID cache:
+
+```rust
+// Fetch components from Status Dashboard V2 API
+let components = fetch_components(&client, &url, &headers).await?;
+
+// Build cache: HashMap<(name, sorted_attributes), component_id>
+let cache = build_component_id_cache(components);
+```
+
+**Retry Logic**:
+- 3 attempts with 60-second delays between retries
+- Reporter exits if all attempts fail (FR-007)
+
+### 2. Polling Loop
+
+The reporter runs an infinite loop with 60-second intervals:
 
 ```rust
 loop {
-    // Sleep for configured interval
-    tokio::time::sleep(Duration::from_secs(poll_interval)).await;
-    
-    // Query all services
-    for service in services {
-        let health = query_convertor(service, environment).await;
-        
-        if health.status > 0 {
-            send_to_dashboard(health).await;
+    // For each environment and service
+    for env in environments {
+        for service in services {
+            let health = query_convertor(service, env).await?;
+            
+            if health.impact > 0 {
+                // Resolve component ID from cache
+                let component_id = find_component_id(&cache, &component)?;
+                
+                // Create incident via V2 API
+                let incident = build_incident_data(component_id, impact, timestamp);
+                create_incident(&client, &url, &headers, &incident).await?;
+            }
         }
     }
+    sleep(Duration::from_secs(60)).await;
 }
 ```
 
-**Configuration**:
-- Poll interval: Typically 60-300 seconds
-- Services to monitor: Defined in configuration
-- Environments: Usually production only
-
-### 2. Health Status Check
+### 3. Component ID Resolution
 
-**Logic**:
-- Status 0 (healthy): No action, service operating normally
-- Status 1 (degraded): Send incident to dashboard
-- Status 2 (outage): Send critical incident to dashboard
+Components are looked up using subset attribute matching:
 
-**Threshold Behavior**:
-- Reporter does not interpret status values
-- Dashboard receives raw status (0/1/2)
-- Dashboard decides incident creation/update logic
+```rust
+// Config attributes must be a SUBSET of cache attributes
+// Example: config has {region: "EU-DE"}
+//          cache has {region: "EU-DE", category: "Storage"}
+// Result: MATCH (config attrs are subset of cache attrs)
+```
 
-### 3. Dashboard Integration
+**Cache Miss Handling**:
+- If component not found, refresh cache once
+- Retry lookup after refresh
+- Log warning and skip if still not found
 
-#### Authentication
+### 4. Incident Creation
 
-The reporter uses JWT tokens for authentication:
+Incidents are created with static, secure payloads:
 
-```
-Header:
+```json
 {
-  "alg": "HS256",
-  "typ": "JWT"
+  "title": "System incident from monitoring system",
+  "description": "System-wide incident affecting one or multiple components. Created automatically.",
+  "impact": 2,
+  "components": [218],
+  "start_date": "2024-01-20T12:00:00Z",
+  "system": true,
+  "type": "incident"
 }
+```
 
-Payload:
-{
-  "service": "api",
-  "environment": "production",
-  "status": 1,
-  "timestamp": 1640000000
-}
+**Important**:
+- Title and description are static (not user-controlled) for security
+- Timestamp is RFC3339 format, minus 1 second from metric timestamp
+- `system: true` indicates auto-generated incident
+
+### 5. Authentication
 
-Signature:
-HMAC-SHA256(
-  base64(header) + "." + base64(payload),
-  secret
-)
+The reporter uses HMAC-JWT for authentication (unchanged from V1):
+
+```rust
+// Generate HMAC-JWT token
+let headers = build_auth_headers(secret.as_deref());
+// Headers contain: Authorization: Bearer <jwt-token>
 ```
 
-**Token Generation**:
-1. Create payload with service info
-2. Sign with HMAC-SHA256 using shared secret
-3. Encode as JWT token
-4. Include in `Authorization: Bearer <token>` header
+**Token Format**:
+- Algorithm: HMAC-SHA256
+- Claims: `{"stackmon": "dummy"}`
+- Optional: No secret = no auth header (for environments without auth)
 
-#### API Request
+## Module Structure
 
-```bash
-curl -X POST https://dashboard.example.com/api/incidents \
-  -H "Authorization: Bearer eyJhbGc..." \
-  -H "Content-Type: application/json" \
-  -d '{
-    "service": "api",
-    "environment": "production",
-    "status": 1,
-    "message": "Service degraded",
-    "timestamp": "2024-01-20T12:00:00Z"
-  }'
+The Status Dashboard integration is consolidated in `src/sd.rs`:
+
+```rust
+// src/sd.rs - Status Dashboard integration module
+
+// Data Structures
+pub struct ComponentAttribute { name, value }
+pub struct Component { name, attributes }
+pub struct StatusDashboardComponent { id, name, attributes }
+pub struct IncidentData { title, description, impact, components, start_date, system, type }
+pub type ComponentCache = HashMap<(String, Vec<ComponentAttribute>), u32>;
+
+// Authentication
+pub fn build_auth_headers(secret: Option<&str>) -> HeaderMap
+
+// V2 API Functions
+pub async fn fetch_components(...) -> Result<Vec<StatusDashboardComponent>>
+pub fn build_component_id_cache(...) -> ComponentCache
+pub fn find_component_id(...) -> Option<u32>
+pub fn build_incident_data(...) -> IncidentData
+pub async fn create_incident(...) -> Result<()>
 ```
 
 ## Configuration
@@ -155,6 +196,24 @@ status_dashboard:
   secret: "your-jwt-secret"
 ```
 
+| Property | Type   | Required | Default | Description                           |
+|----------|--------|----------|---------|---------------------------------------|
+| `url`    | string | Yes      | -       | Status Dashboard API URL              |
+| `secret` | string | No       | -       | JWT signing secret for authentication |
+
+### Health Query Configuration
+
+```yaml
+health_query:
+  query_from: "-5min"  # Start of health metric query window (default: "-5min")
+  query_to: "-2min"    # End of health metric query window (default: "-2min")
+```
+
+| Property     | Type   | Required | Default | Description                                 |
+|--------------|--------|----------|---------|---------------------------------------------|
+| `query_from` | string | No       | `-5min` | Start time offset for health metric queries |
+| `query_to`   | string | No       | `-2min` | End time offset for health metric queries   |
+
 ### Polling Configuration
 
 ```yaml
@@ -253,11 +312,52 @@ cloudmon-metrics-reporter --config config.yaml
 **Logging**:
 ```bash
 RUST_LOG=info cloudmon-metrics-reporter --config config.yaml
+```
+
+#### Log Examples
+
+**Startup - Component Fetch Success**:
+```
+2026-01-29T10:30:00.123456Z  INFO cloudmon_metrics_reporter: starting cloudmon-metrics-reporter
+2026-01-29T10:30:00.234567Z  INFO cloudmon_metrics_reporter: attempting to fetch components from Status Dashboard attempt=1 max_attempts=3
+2026-01-29T10:30:01.345678Z  INFO cloudmon_metrics_reporter: successfully fetched components from Status Dashboard attempt=1 component_count=42
+2026-01-29T10:30:01.456789Z  INFO cloudmon_metrics_reporter: starting metric reporter thread
+```
+
+**Incident Creation - Full Decision Context**:
+When the reporter decides to create an incident, it logs all the information needed to understand why, including the metric template configuration:
+```
+2026-01-29T10:30:44.123456Z  INFO cloudmon_metrics_reporter: creating incident: health metric indicates service degradation environment="prod-eu" service="as" component_name="Auto Scaling" component_id=218 query_from="-5min" query_to="-2min" metric_timestamp=1738145400 impact=2 triggered_metrics=["as.api_down(query=asPercent(smartSummarize(...), smartSummarize(...)), op=eq, threshold=100)"] matched_expression="as.api_down"
+2026-01-29T10:30:45.234567Z  INFO cloudmon_metrics_reporter: incident created successfully component_id=218 impact=2
+```
 
-# Expected logs:
-INFO Polling convertor for service: api
-INFO Health status: 1 (degraded)
-INFO Sent notification to dashboard: success
+**Incident with Multiple Triggered Metrics (weight=1, degraded)**:
+```
+2026-01-29T10:30:44.123456Z  INFO cloudmon_metrics_reporter: creating incident: health metric indicates service degradation environment="prod-eu" service="as" component_name="Auto Scaling" component_id=218 query_from="-5min" query_to="-2min" metric_timestamp=1738145400 impact=1 triggered_metrics=["as.api_slow(query=smartSummarize(...), op=gt, threshold=1000)", "as.api_success_rate_low(query=asPercent(...), op=lt, threshold=99)"] matched_expression="as.api_slow || as.api_success_rate_low"
+```
+
+**Component Cache Miss and Refresh**:
+```
+2026-01-29T10:31:00.123456Z  INFO cloudmon_metrics_reporter: component not found in cache, attempting cache refresh component_name="New Service" service="new-service" environment="prod-eu"
+2026-01-29T10:31:01.234567Z  INFO cloudmon_metrics_reporter: cache refreshed component_count=43
+```
+
+**Error - Failed to Create Incident**:
+```
+2026-01-29T10:30:45.123456Z ERROR cloudmon_metrics_reporter: failed to create incident error="HTTP 422: Invalid component ID" component_id=999 service="compute" environment="prod-eu"
+```
+
+**Error - Component Not Found After Refresh**:
+```
+2026-01-29T10:31:02.123456Z  WARN cloudmon_metrics_reporter: component not found in cache even after refresh, skipping incident creation component_name="Unknown Service" service="unknown" environment="prod-eu"
+```
+
+**Startup Failure - Component Fetch Failed**:
+```
+2026-01-29T10:30:00.123456Z  INFO cloudmon_metrics_reporter: attempting to fetch components from Status Dashboard attempt=1 max_attempts=3
+2026-01-29T10:30:01.234567Z  WARN cloudmon_metrics_reporter: failed to fetch components, will retry after delay error="Connection refused" attempt=1 max_attempts=3 retry_delay_seconds=60
+2026-01-29T10:31:01.345678Z  WARN cloudmon_metrics_reporter: failed to fetch components, will retry after delay error="Connection refused" attempt=2 max_attempts=3 retry_delay_seconds=60
+2026-01-29T10:32:01.456789Z ERROR cloudmon_metrics_reporter: failed to fetch components after all retry attempts, reporter cannot start error="Connection refused" attempt=3 max_attempts=3
 ```
 
 ### Performance
diff --git a/doc/schemas/README.md b/doc/schemas/README.md
index 99e7230..fe2afed 100644
--- a/doc/schemas/README.md
+++ b/doc/schemas/README.md
@@ -26,12 +26,24 @@ This directory contains JSON Schema definitions and pattern documentation design
 // .vscode/settings.json
 {
   "yaml.schemas": {
-    "specs/001-project-documentation/contracts/config-schema.json": "config*.yaml"
+    "doc/schemas/config-schema.json": "config*.yaml"
   }
 }
 ```
 
-**Generated From**: Rust `Config` struct in `src/config.rs` (will be auto-generated via `schemars` crate in implementation)
+**Regenerating the Schema**:
+
+The schema is generated from the actual Rust `Config` struct in `src/config.rs` using the `schemars` crate. To regenerate after config changes:
+
+```bash
+# Using make
+make doc-schema
+
+# Or using cargo directly
+cargo test generate_config_schema -- --ignored --nocapture
+```
+
+This will update `doc/schemas/config-schema.json` with the latest schema.
 
 **Validation Rules**:
 - All required fields must be present (datasource, server, flag_metrics, health_metrics)
diff --git a/doc/schemas/config-schema.json b/doc/schemas/config-schema.json
index 5345793..e7fdaab 100644
--- a/doc/schemas/config-schema.json
+++ b/doc/schemas/config-schema.json
@@ -1,7 +1,7 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Config",
-  "description": "Configuration structure",
+  "description": "A Configuration structure",
   "type": "object",
   "required": [
     "datasource",
@@ -12,7 +12,7 @@
   ],
   "properties": {
     "datasource": {
-      "description": "TSDB datasource connection",
+      "description": "Datasource link",
       "allOf": [
         {
           "$ref": "#/definitions/Datasource"
@@ -20,28 +20,36 @@
       ]
     },
     "environments": {
-      "description": "Environment definitions",
+      "description": "Environments",
       "type": "array",
       "items": {
         "$ref": "#/definitions/EnvironmentDef"
       }
     },
     "flag_metrics": {
-      "description": "Flag metric definitions",
+      "description": "Flag metrics",
       "type": "array",
       "items": {
         "$ref": "#/definitions/FlagMetricDef"
       }
     },
     "health_metrics": {
-      "description": "Health metric definitions per service",
+      "description": "Health metrics",
       "type": "object",
       "additionalProperties": {
         "$ref": "#/definitions/ServiceHealthDef"
       }
     },
+    "health_query": {
+      "description": "Health metrics query configuration",
+      "allOf": [
+        {
+          "$ref": "#/definitions/HealthQueryConfig"
+        }
+      ]
+    },
     "metric_templates": {
-      "description": "Metric query templates",
+      "description": "Metric templates",
       "type": [
         "object",
         "null"
@@ -51,7 +59,7 @@
       }
     },
     "server": {
-      "description": "HTTP server binding configuration",
+      "description": "Server API binding",
       "allOf": [
         {
           "$ref": "#/definitions/ServerConf"
@@ -59,7 +67,7 @@
       ]
     },
     "status_dashboard": {
-      "description": "Status dashboard connection (optional)",
+      "description": "Status Dashboard connection",
       "anyOf": [
         {
           "$ref": "#/definitions/StatusDashboardConfig"
@@ -72,7 +80,6 @@
   },
   "definitions": {
     "BinaryMetricRawDef": {
-      "description": "Binary metric raw definition (template)",
       "type": "object",
       "required": [
         "op",
@@ -81,20 +88,25 @@
       ],
       "properties": {
         "op": {
-          "description": "Comparison operator (lt, gt, eq)",
-          "type": "string"
+          "$ref": "#/definitions/CmpType"
         },
         "query": {
-          "description": "TSDB query template with variable substitution",
           "type": "string"
         },
         "threshold": {
-          "description": "Threshold value for comparison",
           "type": "number",
-          "format": "double"
+          "format": "float"
         }
       }
     },
+    "CmpType": {
+      "type": "string",
+      "enum": [
+        "lt",
+        "gt",
+        "eq"
+      ]
+    },
     "Datasource": {
       "description": "TSDB Datasource connection",
       "type": "object",
@@ -103,54 +115,105 @@
       ],
       "properties": {
         "timeout": {
-          "description": "Query timeout in seconds (default: 10)",
+          "description": "query timeout",
           "default": 10,
           "type": "integer",
           "format": "uint16",
           "minimum": 0.0
         },
         "url": {
-          "description": "TSDB URL (e.g., http://localhost:8080)",
+          "description": "TSDB url",
           "type": "string"
         }
       }
     },
     "EnvironmentDef": {
-      "description": "Environment definition",
       "type": "object",
       "required": [
         "name"
       ],
       "properties": {
+        "attributes": {
+          "type": [
+            "object",
+            "null"
+          ],
+          "additionalProperties": {
+            "type": "string"
+          }
+        },
         "name": {
-          "description": "Environment name (e.g., production, staging)",
           "type": "string"
         }
       }
     },
-    "EnvironmentOverride": {
-      "description": "Environment-specific override",
+    "FlagMetricDef": {
+      "type": "object",
+      "required": [
+        "environments",
+        "name",
+        "service"
+      ],
+      "properties": {
+        "environments": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/MetricEnvironmentDef"
+          }
+        },
+        "name": {
+          "type": "string"
+        },
+        "service": {
+          "type": "string"
+        },
+        "template": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/MetricTemplateRef"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        }
+      }
+    },
+    "HealthQueryConfig": {
+      "description": "Health metrics query configuration",
+      "type": "object",
+      "properties": {
+        "query_from": {
+          "description": "Query start time offset for health metrics (e.g., \"-5min\")",
+          "default": "-5min",
+          "type": "string"
+        },
+        "query_to": {
+          "description": "Query end time offset for health metrics (e.g., \"-2min\")",
+          "default": "-2min",
+          "type": "string"
+        }
+      }
+    },
+    "MetricEnvironmentDef": {
       "type": "object",
       "required": [
         "name"
       ],
       "properties": {
         "name": {
-          "description": "Environment name",
           "type": "string"
         },
         "threshold": {
-          "description": "Overridden threshold (optional)",
           "type": [
             "number",
             "null"
           ],
-          "format": "double"
+          "format": "float"
         }
       }
     },
-    "ExpressionDef": {
-      "description": "Health expression definition",
+    "MetricExpressionDef": {
       "type": "object",
       "required": [
         "expression",
@@ -158,49 +221,31 @@
       ],
       "properties": {
         "expression": {
-          "description": "Boolean expression (e.g., \"api_slow || api_error_rate_high\")",
           "type": "string"
         },
         "weight": {
-          "description": "Weight: 0=healthy, 1=degraded, 2=outage",
           "type": "integer",
-          "format": "uint8",
-          "minimum": 0.0
+          "format": "int32"
         }
       }
     },
-    "FlagMetricDef": {
-      "description": "Flag metric definition",
+    "MetricTemplateRef": {
       "type": "object",
       "required": [
-        "environments",
-        "name",
-        "service",
-        "template"
+        "name"
       ],
       "properties": {
-        "environments": {
-          "description": "Environment-specific overrides",
-          "type": "array",
-          "items": {
-            "$ref": "#/definitions/EnvironmentOverride"
-          }
-        },
         "name": {
-          "description": "Metric name",
-          "type": "string"
-        },
-        "service": {
-          "description": "Service name",
           "type": "string"
         },
-        "template": {
-          "description": "Template reference",
-          "allOf": [
-            {
-              "$ref": "#/definitions/TemplateDef"
-            }
-          ]
+        "vars": {
+          "type": [
+            "object",
+            "null"
+          ],
+          "additionalProperties": {
+            "type": "string"
+          }
         }
       }
     },
@@ -209,12 +254,12 @@
       "type": "object",
       "properties": {
         "address": {
-          "description": "IP address to bind to (default: 0.0.0.0)",
+          "description": "IP address to bind to",
           "default": "0.0.0.0",
           "type": "string"
         },
         "port": {
-          "description": "Port to bind to (default: 3000)",
+          "description": "Port to bind to",
           "default": 3000,
           "type": "integer",
           "format": "uint16",
@@ -223,7 +268,6 @@
       }
     },
     "ServiceHealthDef": {
-      "description": "Service health definition",
       "type": "object",
       "required": [
         "category",
@@ -233,32 +277,27 @@
       ],
       "properties": {
         "category": {
-          "description": "Category (e.g., compute, network, storage)",
           "type": "string"
         },
         "component_name": {
-          "description": "Component display name",
           "type": [
             "string",
             "null"
           ]
         },
         "expressions": {
-          "description": "Boolean expressions with weights",
           "type": "array",
           "items": {
-            "$ref": "#/definitions/ExpressionDef"
+            "$ref": "#/definitions/MetricExpressionDef"
           }
         },
         "metrics": {
-          "description": "List of flag metric names to evaluate",
           "type": "array",
           "items": {
             "type": "string"
           }
         },
         "service": {
-          "description": "Service name",
           "type": "string"
         }
       }
@@ -271,7 +310,7 @@
       ],
       "properties": {
         "secret": {
-          "description": "JWT token signature secret (optional)",
+          "description": "JWT token signature secret",
           "type": [
             "string",
             "null"
@@ -282,19 +321,6 @@
           "type": "string"
         }
       }
-    },
-    "TemplateDef": {
-      "description": "Template reference",
-      "type": "object",
-      "required": [
-        "name"
-      ],
-      "properties": {
-        "name": {
-          "description": "Template name (references metric_templates key)",
-          "type": "string"
-        }
-      }
     }
   }
 }
\ No newline at end of file
diff --git a/doc/testing.md b/doc/testing.md
index 532d254..d3a309a 100644
--- a/doc/testing.md
+++ b/doc/testing.md
@@ -2,7 +2,7 @@
 
 ## Overview
 
-This document describes the comprehensive test suite for the metrics-processor project, including test execution, coverage measurement, and regression protection.
+This document describes the comprehensive test suite for the metrics-processor project, including unit tests, integration tests, E2E tests, coverage measurement, and regression protection.
 
 ## Test Organization
 
@@ -10,32 +10,39 @@ This document describes the comprehensive test suite for the metrics-processor p
 
 ```
 tests/
-├── fixtures/                   # Shared test fixtures and utilities
-│   ├── mod.rs                 # Module declaration
-│   ├── configs.rs             # YAML configuration fixtures
-│   ├── graphite_responses.rs  # Mock Graphite response data
-│   └── helpers.rs             # Test helper functions and assertions
-├── documentation_validation.rs # Documentation validation tests
-├── integration_health.rs       # Service health integration tests
-└── integration_api.rs          # API integration tests
+├── fixtures/                      # Shared test fixtures and utilities
+│   ├── mod.rs                     # Module declaration
+│   ├── configs.rs                 # YAML configuration fixtures
+│   ├── graphite_responses.rs      # Mock Graphite response data
+│   └── helpers.rs                 # Test helper functions and assertions
+├── docker/                        # Docker setup for E2E tests
+│   ├── docker-compose.yml         # go-carbon + carbonapi containers
+│   ├── go-carbon.conf             # Carbon storage configuration
+│   ├── carbonapi.yml              # CarbonAPI configuration
+│   └── README.md                  # Docker setup documentation
+├── integration_e2e_reporter.rs    # E2E tests with real Graphite
+├── integration_health.rs          # Service health integration tests
+├── integration_api.rs             # API integration tests
+└── documentation_validation.rs    # Documentation validation tests
 
 src/
-├── common.rs                  # + #[cfg(test)] mod tests { 11 tests }
-├── types.rs                   # + #[cfg(test)] mod tests { 6 tests }
-├── config.rs                  # + #[cfg(test)] mod tests { 7 tests }
-├── graphite.rs                # + #[cfg(test)] mod tests { 6 tests }
-└── api/v1.rs                  # + #[cfg(test)] mod tests { 4 tests }
+├── common.rs                      # + #[cfg(test)] mod tests { 11 tests }
+├── types.rs                       # + #[cfg(test)] mod tests { 6 tests }
+├── config.rs                      # + #[cfg(test)] mod tests { 7 tests }
+├── graphite.rs                    # + #[cfg(test)] mod tests { 6 tests }
+└── api/v1.rs                      # + #[cfg(test)] mod tests { 4 tests }
 ```
 
 ### Test Categories
 
 1. **Unit Tests**: Located inline with source code using `#[cfg(test)]` modules
 2. **Integration Tests**: Located in `tests/` directory for cross-module scenarios
-3. **Fixtures**: Shared test data and utilities in `tests/fixtures/`
+3. **E2E Tests**: Full pipeline tests with real Docker containers
+4. **Fixtures**: Shared test data and utilities in `tests/fixtures/`
 
 ## Running Tests
 
-### Run All Tests
+### Run All Unit Tests
 
 ```bash
 cargo test
@@ -50,7 +57,7 @@ cargo test common::tests
 # Run only config tests
 cargo test config::tests
 
-# Run only integration tests
+# Run only integration tests (excluding E2E)
 cargo test --test integration_*
 ```
 
@@ -72,6 +79,108 @@ cargo test -- --test-threads=4
 cargo test -- --test-threads=1
 ```
 
+## E2E Integration Tests
+
+The E2E tests (`integration_e2e_reporter.rs`) validate the complete metrics-processor pipeline using real Docker containers.
+
+### What They Test
+
+- Metrics ingestion via Carbon protocol
+- Query processing via CarbonAPI
+- Health expression evaluation
+- Incident creation and severity assignment
+- Reporter log output format and content
+
+### Prerequisites
+
+1. **Docker**: Must be installed and running
+2. **Available Ports**:
+   - `2003` - Carbon plaintext protocol
+   - `8080` - CarbonAPI query endpoint
+   - `3005` - Convertor API
+   - `9999` - Mock Status Dashboard
+
+### Running E2E Tests
+
+```bash
+# Run E2E tests (Docker containers managed automatically)
+cargo test --test integration_e2e_reporter -- --ignored --nocapture
+```
+
+The test automatically:
+1. Restarts Docker containers to ensure clean state
+2. Builds convertor and reporter binaries
+3. Runs all 4 test scenarios
+4. Validates log output for each scenario
+
+### Test Scenarios
+
+| Scenario | Weight | Condition | Expected Log |
+|----------|--------|-----------|--------------|
+| `healthy` | 0 | All metrics OK | No incident log |
+| `degraded_slow` | 1 | Response time > 1200ms | `matched_expression="...api_slow..."` |
+| `degraded_errors` | 1 | Success rate < 65% | `matched_expression="...api_success_rate_low..."` |
+| `outage` | 2 | 100% failures | `matched_expression="...api_down"` |
+
+### E2E Test Architecture
+
+```
+┌─────────────┐     ┌─────────────┐     ┌─────────────┐
+│  Test Code  │────▶│  go-carbon  │────▶│  carbonapi  │
+│(write data) │     │  (storage)  │     │   (query)   │
+└─────────────┘     └─────────────┘     └─────────────┘
+                                               │
+      ┌────────────────────────────────────────┘
+      ▼
+┌─────────────┐     ┌─────────────┐     ┌─────────────┐
+│  Convertor  │────▶│  Reporter   │────▶│ Mock Status │
+│  (process)  │     │   (alert)   │     │  Dashboard  │
+└─────────────┘     └─────────────┘     └─────────────┘
+      │                   │
+      │                   ▼
+      │             ┌─────────────┐
+      └────────────▶│  Log Output │◀── Test validates
+                    │  (stdout)   │
+                    └─────────────┘
+```
+
+### Data Isolation
+
+Each scenario uses a unique service name (e.g., `rms_healthy`, `rms_outage`) to prevent data pollution between scenarios. This allows sequential execution without clearing Graphite data.
+
+### E2E Troubleshooting
+
+#### "Docker containers failed to start"
+```bash
+# Check Docker is running
+docker ps
+
+# Check port availability
+lsof -i :2003 -i :8080 -i :3005 -i :9999
+
+# Manually start containers
+cd tests/docker && docker compose up -d
+```
+
+#### "Convertor not ready after timeout"
+- The convertor may need more time to start
+- Check for port conflicts on 3005
+- Review convertor stderr output
+
+#### "No incident log found"
+```bash
+# Verify Graphite received data
+curl 'http://localhost:8080/metrics/find?query=stats.*&format=json'
+
+# Check go-carbon logs
+docker logs metrics-processor-go-carbon
+```
+
+#### "Log validation failed"
+- Verify expected expression matches the config
+- Check for ANSI escape codes (test strips them automatically)
+- Review the full log output in test output
+
 ## Test Coverage
 
 ### Measuring Coverage
diff --git a/specs/003-sd-api-v2-migration/checklists/requirements.md b/specs/003-sd-api-v2-migration/checklists/requirements.md
new file mode 100644
index 0000000..81d8309
--- /dev/null
+++ b/specs/003-sd-api-v2-migration/checklists/requirements.md
@@ -0,0 +1,54 @@
+# Specification Quality Checklist: Reporter Migration to Status Dashboard API V2
+
+**Purpose**: Validate specification completeness and quality before proceeding to planning  
+**Created**: 2025-01-22  
+**Feature**: [spec.md](../spec.md)
+
+## Content Quality
+
+- [x] No implementation details (languages, frameworks, APIs)
+- [x] Focused on user value and business needs
+- [x] Written for non-technical stakeholders
+- [x] All mandatory sections completed
+
+## Requirement Completeness
+
+- [x] No [NEEDS CLARIFICATION] markers remain
+- [x] Requirements are testable and unambiguous
+- [x] Success criteria are measurable
+- [x] Success criteria are technology-agnostic (no implementation details)
+- [x] All acceptance scenarios are defined
+- [x] Edge cases are identified
+- [x] Scope is clearly bounded
+- [x] Dependencies and assumptions identified
+
+## Feature Readiness
+
+- [x] All functional requirements have clear acceptance criteria
+- [x] User scenarios cover primary flows
+- [x] Feature meets measurable outcomes defined in Success Criteria
+- [x] No implementation details leak into specification
+
+## Validation Results
+
+### Initial Review (2025-01-22)
+
+All checklist items passed on initial review:
+
+✅ **Content Quality**: The specification focuses on what the reporter needs to accomplish (migrate from V1 to V2 API) without prescribing implementation details. While it references specific API endpoints and data structures, these are part of the external API contract that the reporter must integrate with, not implementation choices.
+
+✅ **Requirement Completeness**: All requirements are testable and unambiguous. No clarifications needed - the feature scope is well-defined based on the existing V1 implementation and the V2 API schema.
+
+✅ **Feature Readiness**: The three prioritized user stories cover the complete migration scope:
+- P1: Core incident creation via V2 API (essential MVP)
+- P2: Component cache management (enables robustness)
+- P3: Authorization compatibility (confirms backward compatibility)
+
+Each story is independently testable and delivers standalone value.
+
+## Notes
+
+- The specification references API endpoints and data structures because these are external contracts defined by the Status Dashboard API V2, not implementation details of the reporter
+- The feature scope is constrained to incident creation only; incident updates and closures are explicitly out of scope
+- Authorization remains unchanged, minimizing migration risk
+- Component cache management is essential for efficient operation and handling dynamic component additions
diff --git a/specs/003-sd-api-v2-migration/contracts/README.md b/specs/003-sd-api-v2-migration/contracts/README.md
new file mode 100644
index 0000000..48ee2c9
--- /dev/null
+++ b/specs/003-sd-api-v2-migration/contracts/README.md
@@ -0,0 +1,57 @@
+# API Contracts: Status Dashboard V2
+
+**Feature**: Reporter Migration to Status Dashboard API V2  
+**Date**: 2025-01-23
+
+This directory contains API contract specifications for the Status Dashboard V2 endpoints used by the reporter.
+
+## Files
+
+- `components-api.yaml`: GET /v2/components endpoint contract
+- `incidents-api.yaml`: POST /v2/incidents endpoint contract
+- `request-examples/`: Sample request payloads
+- `response-examples/`: Sample response payloads
+
+## Source
+
+All contracts are derived from the project's OpenAPI specification:
+- **File**: `/openapi.yaml` (project root)
+- **Version**: Status Dashboard API 1.0.0
+- **Endpoints Used**:
+  - `GET /v2/components` (line 138-151)
+  - `POST /v2/incidents` (line 254-270)
+
+## Testing
+
+Contracts can be validated using OpenAPI tooling:
+
+```bash
+# Validate against OpenAPI schema
+npx @redocly/cli lint openapi.yaml
+
+# Generate mock server for testing
+npx @stoplight/prism mock openapi.yaml
+```
+
+## Usage in Reporter
+
+### Components Endpoint
+```rust
+// Fetch all components at startup
+let components: Vec<StatusDashboardComponent> = 
+    req_client.get(&format!("{}/v2/components", sdb_url))
+    .send().await?
+    .json().await?;
+```
+
+### Incidents Endpoint
+```rust
+// Create incident
+let incident = IncidentData { /* ... */ };
+let response: IncidentPostResponse = 
+    req_client.post(&format!("{}/v2/incidents", sdb_url))
+    .headers(auth_headers)
+    .json(&incident)
+    .send().await?
+    .json().await?;
+```
diff --git a/specs/003-sd-api-v2-migration/contracts/components-api.md b/specs/003-sd-api-v2-migration/contracts/components-api.md
new file mode 100644
index 0000000..7bf88f3
--- /dev/null
+++ b/specs/003-sd-api-v2-migration/contracts/components-api.md
@@ -0,0 +1,296 @@
+# GET /v2/components
+
+## Overview
+
+Fetch all components from Status Dashboard to build the component ID cache.
+
+**Endpoint**: `GET /v2/components`  
+**Authentication**: Optional (HMAC-JWT Bearer token if configured)  
+**Frequency**: Startup + on-demand cache refresh
+
+## Request
+
+### HTTP Method
+```
+GET /v2/components HTTP/1.1
+Host: {status-dashboard-url}
+Authorization: Bearer {jwt-token}
+```
+
+### Headers
+
+| Header | Required | Value | Description |
+|--------|----------|-------|-------------|
+| `Authorization` | Optional | `Bearer {jwt-token}` | HMAC-signed JWT if secret configured |
+
+### Query Parameters
+
+None.
+
+### Request Body
+
+None (GET request).
+
+## Response
+
+### Success Response (200 OK)
+
+**Content-Type**: `application/json`
+
+**Schema**:
+```yaml
+type: array
+items:
+  type: object
+  required: [id, name, attributes]
+  properties:
+    id:
+      type: integer
+      format: int64
+      description: Component ID (primary key)
+      example: 218
+    name:
+      type: string
+      description: Component name
+      example: "Object Storage Service"
+    attributes:
+      type: array
+      items:
+        type: object
+        properties:
+          name:
+            type: string
+            enum: [category, region, type]
+            description: Attribute name
+            example: "category"
+          value:
+            type: string
+            description: Attribute value
+            example: "Storage"
+```
+
+**Example Response**:
+```json
+[
+  {
+    "id": 218,
+    "name": "Object Storage Service",
+    "attributes": [
+      {
+        "name": "category",
+        "value": "Storage"
+      },
+      {
+        "name": "region",
+        "value": "EU-DE"
+      }
+    ]
+  },
+  {
+    "id": 254,
+    "name": "Compute Service",
+    "attributes": [
+      {
+        "name": "category",
+        "value": "Compute"
+      },
+      {
+        "name": "region",
+        "value": "EU-NL"
+      },
+      {
+        "name": "type",
+        "value": "vm"
+      }
+    ]
+  },
+  {
+    "id": 312,
+    "name": "Database Service",
+    "attributes": []
+  }
+]
+```
+
+### Error Responses
+
+#### 401 Unauthorized
+Invalid or missing authentication token (if auth required).
+
+```json
+{
+  "errMsg": "Invalid or missing authorization token"
+}
+```
+
+#### 500 Internal Server Error
+Server-side error.
+
+```json
+{
+  "errMsg": "internal server error"
+}
+```
+
+## Rust Implementation
+
+### Request Struct
+
+```rust
+// No request body struct needed (GET request)
+```
+
+### Response Struct
+
+```rust
+#[derive(Clone, Deserialize, Serialize, Debug)]
+pub struct StatusDashboardComponent {
+    pub id: u32,
+    pub name: String,
+    #[serde(default)]
+    pub attributes: Vec<ComponentAttribute>,
+}
+
+#[derive(Clone, Deserialize, Serialize, Debug, PartialEq, Eq, Hash, Ord, PartialOrd)]
+pub struct ComponentAttribute {
+    pub name: String,
+    pub value: String,
+}
+```
+
+### Usage Example
+
+```rust
+use reqwest::{Client, header::{HeaderMap, AUTHORIZATION}};
+use serde::Deserialize;
+
+async fn fetch_components(
+    client: &Client,
+    base_url: &str,
+    auth_headers: &HeaderMap,
+) -> Result<Vec<StatusDashboardComponent>, Box<dyn std::error::Error>> {
+    let url = format!("{}/v2/components", base_url);
+    
+    let response = client
+        .get(&url)
+        .headers(auth_headers.clone())
+        .send()
+        .await?;
+    
+    response.error_for_status_ref()?;
+    
+    let components = response.json::<Vec<StatusDashboardComponent>>().await?;
+    
+    tracing::info!("Fetched {} components from Status Dashboard", components.len());
+    
+    Ok(components)
+}
+```
+
+## Cache Building
+
+Once components are fetched, build the cache:
+
+```rust
+use std::collections::HashMap;
+
+fn build_component_id_cache(
+    components: Vec<StatusDashboardComponent>
+) -> HashMap<(String, Vec<ComponentAttribute>), u32> {
+    components.into_iter().map(|c| {
+        let mut attrs = c.attributes;
+        attrs.sort();  // Ensure deterministic cache key
+        ((c.name, attrs), c.id)
+    }).collect()
+}
+```
+
+## Error Handling
+
+```rust
+async fn fetch_components_with_retry(
+    client: &Client,
+    base_url: &str,
+    auth_headers: &HeaderMap,
+) -> Option<Vec<StatusDashboardComponent>> {
+    for attempt in 1..=3 {
+        match fetch_components(client, base_url, auth_headers).await {
+            Ok(components) => {
+                tracing::info!("Successfully fetched {} components", components.len());
+                return Some(components);
+            }
+            Err(e) => {
+                tracing::error!("Failed to fetch components (attempt {}/3): {}", attempt, e);
+                if attempt < 3 {
+                    tracing::info!("Retrying in 60 seconds...");
+                    tokio::time::sleep(Duration::from_secs(60)).await;
+                } else {
+                    tracing::error!("Could not fetch components after 3 attempts");
+                    return None;
+                }
+            }
+        }
+    }
+    None
+}
+```
+
+## Contract Validation
+
+### Valid Response Examples
+
+✅ **Complete component with attributes**:
+```json
+{
+  "id": 218,
+  "name": "Object Storage Service",
+  "attributes": [
+    {"name": "region", "value": "EU-DE"}
+  ]
+}
+```
+
+✅ **Component without attributes**:
+```json
+{
+  "id": 312,
+  "name": "Database Service",
+  "attributes": []
+}
+```
+
+### Invalid Response Examples
+
+❌ **Missing required field `id`**:
+```json
+{
+  "name": "Storage",
+  "attributes": []
+}
+```
+*Error*: Serde deserialization fails
+
+❌ **Invalid attribute structure**:
+```json
+{
+  "id": 218,
+  "name": "Storage",
+  "attributes": [
+    {"key": "region", "val": "EU-DE"}  // Should be "name" and "value"
+  ]
+}
+```
+*Error*: Serde deserialization fails
+
+## Performance Considerations
+
+- **Response Size**: ~100 components × ~200 bytes = ~20 KB (small payload)
+- **Frequency**: Once at startup + rare refreshes (only on cache miss)
+~~- **Timeout**: Use 10-second timeout per FR-014~~
+- **Caching**: Store in memory for duration of reporter process
+
+## Security
+
+- **Authentication**: Same HMAC-JWT mechanism as V1 API (FR-008)
+- **Data Exposure**: Component names and attributes are public data (Status Dashboard is public)
+- **Authorization**: Reporter only needs read access to components endpoint
diff --git a/specs/003-sd-api-v2-migration/contracts/incidents-api.md b/specs/003-sd-api-v2-migration/contracts/incidents-api.md
new file mode 100644
index 0000000..eb3671d
--- /dev/null
+++ b/specs/003-sd-api-v2-migration/contracts/incidents-api.md
@@ -0,0 +1,468 @@
+# POST /v2/incidents
+
+## Overview
+
+Create a new incident in Status Dashboard when a service health issue is detected.
+
+**Endpoint**: `POST /v2/incidents`  
+**Authentication**: Required (HMAC-JWT Bearer token)  
+**Frequency**: Per health issue detection (~1-10 incidents/min under normal load)
+
+## Request
+
+### HTTP Method
+```
+POST /v2/incidents HTTP/1.1
+Host: {status-dashboard-url}
+Authorization: Bearer {jwt-token}
+Content-Type: application/json
+```
+
+### Headers
+
+| Header | Required | Value | Description |
+|--------|----------|-------|-------------|
+| `Authorization` | Yes | `Bearer {jwt-token}` | HMAC-signed JWT (unchanged from V1) |
+| `Content-Type` | Yes | `application/json` | Request body format |
+
+### Request Body
+
+**Schema**:
+```yaml
+type: object
+required: [title, impact, components, start_date, type]
+properties:
+  title:
+    type: string
+    description: Incident title (static for auto-created)
+    example: "System incident from monitoring system"
+  description:
+    type: string
+    description: Generic description (optional, defaults to empty)
+    example: "System-wide incident affecting one or multiple components. Created automatically."
+  impact:
+    type: integer
+    enum: [0, 1, 2, 3]
+    description: "Impact level: 0=none, 1=minor, 2=major, 3=critical"
+    example: 2
+  components:
+    type: array
+    items:
+      type: integer
+    description: Array of component IDs (resolved from cache)
+    example: [218]
+  start_date:
+    type: string
+    format: date-time
+    description: Incident start time (RFC3339, health metric timestamp - 1s)
+    example: "2025-01-22T10:30:44Z"
+  end_date:
+    type: string
+    format: date-time
+    description: Incident end time (optional, not used for auto-created)
+  system:
+    type: boolean
+    default: false
+    description: System-generated flag (true for auto-created)
+    example: true
+  type:
+    type: string
+    enum: [incident, maintenance]
+    description: Event type (always "incident" for auto-created)
+    example: "incident"
+```
+
+**Example Request Body** (typical auto-created incident):
+```json
+{
+  "title": "System incident from monitoring system",
+  "description": "System-wide incident affecting one or multiple components. Created automatically.",
+  "impact": 2,
+  "components": [218],
+  "start_date": "2025-01-22T10:30:44Z",
+  "system": true,
+  "type": "incident"
+}
+```
+
+**Example Request Body** (multi-component incident):
+```json
+{
+  "title": "System incident from monitoring system",
+  "description": "System-wide incident affecting one or multiple components. Created automatically.",
+  "impact": 3,
+  "components": [218, 254, 312],
+  "start_date": "2025-01-22T10:30:44Z",
+  "system": true,
+  "type": "incident"
+}
+```
+
+## Response
+
+### Success Response (200 OK)
+
+**Content-Type**: `application/json`
+
+**Schema**:
+```yaml
+type: object
+properties:
+  result:
+    type: array
+    items:
+      type: object
+      properties:
+        component_id:
+          type: integer
+          format: int64
+          description: Component ID from request
+        incident_id:
+          type: integer
+          format: int64
+          description: Created or existing incident ID
+```
+
+**Example Response** (new incident created):
+```json
+{
+  "result": [
+    {
+      "component_id": 218,
+      "incident_id": 456
+    }
+  ]
+}
+```
+
+**Example Response** (existing incident returned - duplicate detection):
+```json
+{
+  "result": [
+    {
+      "component_id": 218,
+      "incident_id": 123
+    }
+  ]
+}
+```
+
+**Duplicate Handling**: If an identical incident already exists (same component + impact + active), the API returns the existing incident ID. The reporter does not need to implement deduplication logic (FR-016).
+
+### Error Responses
+
+#### 400 Bad Request
+Invalid request body (missing required fields, invalid impact value, etc.).
+
+```json
+{
+  "errMsg": "Invalid request: impact must be between 0 and 3"
+}
+```
+
+#### 401 Unauthorized
+Invalid or missing authentication token.
+
+```json
+{
+  "errMsg": "Invalid or missing authorization token"
+}
+```
+
+#### 404 Not Found
+Component ID(s) not found in Status Dashboard.
+
+```json
+{
+  "errMsg": "component does not exist"
+}
+```
+
+#### 500 Internal Server Error
+Server-side error.
+
+```json
+{
+  "errMsg": "internal server error"
+}
+```
+
+## Rust Implementation
+
+### Request Struct
+
+```rust
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Deserialize, Serialize, Debug)]
+pub struct IncidentData {
+    pub title: String,
+    #[serde(default)]
+    pub description: String,
+    pub impact: u8,
+    pub components: Vec<u32>,
+    pub start_date: DateTime<Utc>,
+    #[serde(default)]
+    pub system: bool,
+    #[serde(rename = "type")]
+    pub incident_type: String,
+}
+```
+
+### Response Struct
+
+```rust
+#[derive(Clone, Deserialize, Serialize, Debug)]
+pub struct IncidentPostResponse {
+    pub result: Vec<IncidentPostResult>,
+}
+
+#[derive(Clone, Deserialize, Serialize, Debug)]
+pub struct IncidentPostResult {
+    pub component_id: u32,
+    pub incident_id: u32,
+}
+```
+
+### Usage Example
+
+```rust
+use reqwest::{Client, header::HeaderMap};
+
+async fn create_incident(
+    client: &Client,
+    base_url: &str,
+    auth_headers: &HeaderMap,
+    incident: &IncidentData,
+) -> Result<IncidentPostResponse, Box<dyn std::error::Error>> {
+    let url = format!("{}/v2/incidents", base_url);
+    
+    let response = client
+        .post(&url)
+        .headers(auth_headers.clone())
+        .json(incident)
+        .send()
+        .await?;
+    
+    if !response.status().is_success() {
+        let status = response.status();
+        let body = response.text().await?;
+        tracing::error!("Incident creation failed [{}]: {}", status, body);
+        return Err(format!("API error: {} - {}", status, body).into());
+    }
+    
+    let result = response.json::<IncidentPostResponse>().await?;
+    tracing::info!(
+        "Incident created: component_id={}, incident_id={}",
+        result.result[0].component_id,
+        result.result[0].incident_id
+    );
+    
+    Ok(result)
+}
+```
+
+### Building IncidentData
+
+```rust
+fn build_incident_data(
+    component_id: u32,
+    impact: u8,
+    timestamp: i64,
+) -> IncidentData {
+    use chrono::{DateTime, Utc};
+    
+    // Adjust timestamp by -1 second per FR-011
+    let start_date = DateTime::<Utc>::from_timestamp(timestamp - 1, 0)
+        .expect("Invalid timestamp");
+    
+    IncidentData {
+        title: "System incident from monitoring system".to_string(),
+        description: "System-wide incident affecting one or multiple components. Created automatically.".to_string(),
+        impact,
+        components: vec![component_id],
+        start_date,
+        system: true,
+        incident_type: "incident".to_string(),
+    }
+}
+```
+
+### Error Handling
+
+```rust
+async fn report_incident(
+    client: &Client,
+    base_url: &str,
+    auth_headers: &HeaderMap,
+    incident: &IncidentData,
+) {
+    match create_incident(client, base_url, auth_headers, incident).await {
+        Ok(response) => {
+            tracing::info!(
+                "Successfully created/updated incident {} for component {}",
+                response.result[0].incident_id,
+                response.result[0].component_id
+            );
+        }
+        Err(e) => {
+            tracing::error!("Failed to create incident: {}", e);
+            // Do not retry immediately - next monitoring cycle will retry (FR-015)
+        }
+    }
+}
+```
+
+## Contract Validation
+
+### Valid Request Examples
+
+✅ **Minimal auto-created incident**:
+```json
+{
+  "title": "System incident from monitoring system",
+  "impact": 1,
+  "components": [218],
+  "start_date": "2025-01-22T10:30:44Z",
+  "type": "incident"
+}
+```
+
+✅ **Complete auto-created incident**:
+```json
+{
+  "title": "System incident from monitoring system",
+  "description": "System-wide incident affecting one or multiple components. Created automatically.",
+  "impact": 3,
+  "components": [218],
+  "start_date": "2025-01-22T10:30:44Z",
+  "system": true,
+  "type": "incident"
+}
+```
+
+### Invalid Request Examples
+
+❌ **Missing required field `title`**:
+```json
+{
+  "impact": 2,
+  "components": [218],
+  "start_date": "2025-01-22T10:30:44Z",
+  "type": "incident"
+}
+```
+*Error*: 400 Bad Request
+
+❌ **Invalid impact value**:
+```json
+{
+  "title": "Incident",
+  "impact": 5,
+  "components": [218],
+  "start_date": "2025-01-22T10:30:44Z",
+  "type": "incident"
+}
+```
+*Error*: 400 Bad Request (impact must be 0-3)
+
+❌ **Empty components array**:
+```json
+{
+  "title": "Incident",
+  "impact": 2,
+  "components": [],
+  "start_date": "2025-01-22T10:30:44Z",
+  "type": "incident"
+}
+```
+*Error*: 400 Bad Request (at least one component required)
+
+❌ **Invalid date format**:
+```json
+{
+  "title": "Incident",
+  "impact": 2,
+  "components": [218],
+  "start_date": "2025-01-22 10:30:44",
+  "type": "incident"
+}
+```
+*Error*: 400 Bad Request (must be RFC3339 format)
+
+## Field Constraints (FR-002)
+
+| Field | Value | Rationale |
+|-------|-------|-----------|
+| `title` | `"System incident from monitoring system"` | Static generic title (FR-002) |
+| `description` | `"System-wide incident affecting one or multiple components. Created automatically."` | Static generic description (FR-017, prevents sensitive data exposure) |
+| `impact` | 0-3 from health metric | Direct mapping from service health (FR-002) |
+| `components` | `[component_id]` | Resolved from cache lookup (FR-004) |
+| `start_date` | Health timestamp - 1s | RFC3339 format, adjusted per FR-011 |
+| `system` | `true` | Always true for auto-created (FR-009) |
+| `type` | `"incident"` | Always "incident" for auto-created (FR-010) |
+
+## Sensitive Data Separation (FR-017)
+
+### Data NOT Sent to API (Logged Locally Only)
+
+The following information MUST NOT be included in the incident payload to prevent exposing sensitive operational data on the public Status Dashboard:
+
+- ❌ Service name (e.g., "swift", "nova")
+- ❌ Environment name (e.g., "production", "staging")
+- ❌ Component name (e.g., "Object Storage Service")
+- ❌ Component attributes (e.g., `region=EU-DE`)
+- ❌ Triggered metric names (e.g., "latency_p95", "error_rate")
+- ❌ Metric values (e.g., "latency=450ms")
+
+### Data Logged Locally (For Diagnostics)
+
+```rust
+tracing::info!(
+    timestamp = %start_date,
+    service = %service_name,
+    environment = %env_name,
+    component_name = %component.name,
+    component_attrs = ?component.attributes,
+    component_id = component_id,
+    impact = impact,
+    triggered_metrics = ?triggered_metric_names,
+    "Creating incident for health issue"
+);
+```
+
+### Data Sent to API (Public, Generic)
+
+```json
+{
+  "title": "System incident from monitoring system",
+  "description": "System-wide incident affecting one or multiple components. Created automatically.",
+  "impact": 2,
+  "components": [218],
+  "start_date": "2025-01-22T10:30:44Z",
+  "system": true,
+  "type": "incident"
+}
+```
+
+## Performance Considerations
+
+- **Request Size**: ~300 bytes per incident (small payload)
+- **Frequency**: ~1-10 incidents/min under normal load, higher during widespread issues
+~~- **Timeout**: 10 seconds per FR-014 (increased from 2s)~~
+- **Retry Strategy**: No immediate retry on failure, rely on next monitoring cycle (~60s per FR-015)
+
+## Security
+
+- **Authentication**: HMAC-JWT Bearer token (unchanged from V1, FR-008)
+- **Data Privacy**: Generic title/description prevent sensitive data exposure (FR-017)
+- **Component IDs**: Integer IDs expose less information than names/attributes
+- **Public Dashboard**: All incident data is publicly visible on Status Dashboard
+
+## Idempotency
+
+The Status Dashboard API implements built-in duplicate detection:
+- If an identical incident exists (same component + impact + still active), the API returns the existing incident ID
+- The reporter does NOT need to track created incidents (FR-016)
+- Each health issue detection results in a new POST request, API handles deduplication
diff --git a/specs/003-sd-api-v2-migration/contracts/request-examples/create-incident-multi-component.json b/specs/003-sd-api-v2-migration/contracts/request-examples/create-incident-multi-component.json
new file mode 100644
index 0000000..49fa42b
--- /dev/null
+++ b/specs/003-sd-api-v2-migration/contracts/request-examples/create-incident-multi-component.json
@@ -0,0 +1,9 @@
+{
+  "title": "System incident from monitoring system",
+  "description": "System-wide incident affecting one or multiple components. Created automatically.",
+  "impact": 3,
+  "components": [218, 254, 312],
+  "start_date": "2025-01-22T10:30:44Z",
+  "system": true,
+  "type": "incident"
+}
diff --git a/specs/003-sd-api-v2-migration/contracts/request-examples/create-incident-single-component.json b/specs/003-sd-api-v2-migration/contracts/request-examples/create-incident-single-component.json
new file mode 100644
index 0000000..48288a3
--- /dev/null
+++ b/specs/003-sd-api-v2-migration/contracts/request-examples/create-incident-single-component.json
@@ -0,0 +1,9 @@
+{
+  "title": "System incident from monitoring system",
+  "description": "System-wide incident affecting one or multiple components. Created automatically.",
+  "impact": 2,
+  "components": [218],
+  "start_date": "2025-01-22T10:30:44Z",
+  "system": true,
+  "type": "incident"
+}
diff --git a/specs/003-sd-api-v2-migration/contracts/response-examples/components-list.json b/specs/003-sd-api-v2-migration/contracts/response-examples/components-list.json
new file mode 100644
index 0000000..1756953
--- /dev/null
+++ b/specs/003-sd-api-v2-migration/contracts/response-examples/components-list.json
@@ -0,0 +1,39 @@
+[
+  {
+    "id": 218,
+    "name": "Object Storage Service",
+    "attributes": [
+      {
+        "name": "category",
+        "value": "Storage"
+      },
+      {
+        "name": "region",
+        "value": "EU-DE"
+      }
+    ]
+  },
+  {
+    "id": 254,
+    "name": "Compute Service",
+    "attributes": [
+      {
+        "name": "category",
+        "value": "Compute"
+      },
+      {
+        "name": "region",
+        "value": "EU-NL"
+      },
+      {
+        "name": "type",
+        "value": "vm"
+      }
+    ]
+  },
+  {
+    "id": 312,
+    "name": "Database Service",
+    "attributes": []
+  }
+]
diff --git a/specs/003-sd-api-v2-migration/contracts/response-examples/incident-created.json b/specs/003-sd-api-v2-migration/contracts/response-examples/incident-created.json
new file mode 100644
index 0000000..7b24bb2
--- /dev/null
+++ b/specs/003-sd-api-v2-migration/contracts/response-examples/incident-created.json
@@ -0,0 +1,8 @@
+{
+  "result": [
+    {
+      "component_id": 218,
+      "incident_id": 456
+    }
+  ]
+}
diff --git a/specs/003-sd-api-v2-migration/data-model.md b/specs/003-sd-api-v2-migration/data-model.md
new file mode 100644
index 0000000..4f99385
--- /dev/null
+++ b/specs/003-sd-api-v2-migration/data-model.md
@@ -0,0 +1,785 @@
+# Data Model: Status Dashboard API V2 Migration
+
+**Feature**: Reporter Migration to Status Dashboard API V2  
+**Branch**: `003-sd-api-v2-migration`  
+**Date**: 2025-01-23
+
+## Overview
+
+This document defines the data entities and their relationships for the Status Dashboard API V2 migration. The migration introduces a component ID caching layer and restructures incident data to align with the V2 API schema.
+
+---
+
+## Core Entities
+
+### 1. ComponentAttribute
+
+**Purpose**: Represents a key-value attribute that qualifies a component (e.g., `region=EU-DE`, `category=Storage`)
+
+**Rust Definition**:
+```rust
+#[derive(Clone, Deserialize, Serialize, Debug, PartialEq, Eq, Hash, Ord, PartialOrd)]
+pub struct ComponentAttribute {
+    pub name: String,   // Attribute name (e.g., "region", "category", "type")
+    pub value: String,  // Attribute value (e.g., "EU-DE", "Storage")
+}
+```
+
+**JSON Representation** (Status Dashboard API V2):
+```json
+{
+  "name": "region",
+  "value": "EU-DE"
+}
+```
+
+**Validation Rules**:
+- `name`: Non-empty string, typically one of `["region", "category", "type"]` (per OpenAPI enum)
+- `value`: Non-empty string
+
+**Traits**:
+- `PartialOrd`, `Ord`: Required for sorting attributes before caching
+- `Hash`, `Eq`: Required for use in HashMap keys
+- `Serialize`, `Deserialize`: JSON API interaction
+
+**Relationships**:
+- **Owned by**: `Component` (from config), `StatusDashboardComponent` (from API)
+- **Used in**: Component cache key construction
+
+---
+
+### 2. Component (Config)
+
+**Purpose**: Represents a component definition from the reporter's configuration file. Used to look up component IDs in the cache.
+
+**Rust Definition**:
+```rust
+#[derive(Clone, Deserialize, Serialize, Debug)]
+pub struct Component {
+    pub name: String,                    // Component name (e.g., "Object Storage Service")
+    pub attributes: Vec<ComponentAttribute>,  // Attributes from config + environment
+}
+```
+
+**Source**: Reporter configuration (`config.yaml`)
+
+**Example**:
+```yaml
+# In config.yaml health_metrics section
+health_metrics:
+  swift:
+    component_name: "Object Storage Service"
+    # attributes come from environment.attributes
+
+environments:
+  - name: production
+    attributes:
+      region: "EU-DE"
+      category: "Storage"
+```
+
+**Construction Logic** (from `reporter.rs`):
+```rust
+// Combines component_name from health_metric + attributes from environment
+let component = Component {
+    name: health_metric.component_name.clone(),
+    attributes: env.attributes.clone(),
+};
+```
+
+**Relationships**:
+- **Created from**: Configuration file (`config.yaml`)
+- **Used for**: Component ID cache lookup
+- **Key construction**: `(component.name, sorted(component.attributes))` → cache key
+
+---
+
+### 3. StatusDashboardComponent (API Response)
+
+**Purpose**: Represents a component as returned by the Status Dashboard API `/v2/components` endpoint. Used to build the component ID cache.
+
+**Rust Definition**:
+```rust
+#[derive(Clone, Deserialize, Serialize, Debug)]
+pub struct StatusDashboardComponent {
+    pub id: u32,                         // Component ID (primary key in Status Dashboard)
+    pub name: String,                    // Component name
+    #[serde(default)]
+    pub attributes: Vec<ComponentAttribute>,  // Component attributes (may be empty)
+}
+```
+
+**JSON Representation** (API response from `GET /v2/components`):
+```json
+{
+  "id": 218,
+  "name": "Object Storage Service",
+  "attributes": [
+    {"name": "category", "value": "Storage"},
+    {"name": "region", "value": "EU-DE"}
+  ]
+}
+```
+
+**Source**: Status Dashboard API `/v2/components` endpoint
+
+**Validation Rules**:
+- `id`: Positive integer (u32)
+- `name`: Non-empty string
+- `attributes`: Array (may be empty per `#[serde(default)]`)
+
+**Relationships**:
+- **Fetched from**: Status Dashboard API
+- **Used to build**: Component ID cache (`ComponentCache`)
+- **Cache entry**: `(name, sorted(attributes))` → `id`
+
+---
+
+### 4. ComponentCache
+
+**Purpose**: In-memory cache mapping component names and attributes to component IDs. Avoids repeated API calls during monitoring cycles.
+
+**Rust Definition**:
+```rust
+type ComponentCache = HashMap<(String, Vec<ComponentAttribute>), u32>;
+// Key: (component_name, sorted_attributes)
+// Value: component_id
+```
+
+**Example Cache State**:
+```rust
+{
+    ("Object Storage Service", vec![
+        ComponentAttribute { name: "category", value: "Storage" },
+        ComponentAttribute { name: "region", value: "EU-DE" },
+    ]): 218,
+    
+    ("Compute Service", vec![
+        ComponentAttribute { name: "category", value: "Compute" },
+        ComponentAttribute { name: "region", value: "EU-NL" },
+    ]): 254,
+}
+```
+
+**Cache Operations**:
+1. **Build** (startup):
+   ```rust
+   fn build_component_id_cache(components: Vec<StatusDashboardComponent>) 
+       -> ComponentCache 
+   {
+       components.into_iter().map(|c| {
+           let mut attrs = c.attributes;
+           attrs.sort();  // Ensure deterministic key
+           ((c.name, attrs), c.id)
+       }).collect()
+   }
+   ```
+
+2. **Lookup**:
+   ```rust
+   fn lookup_component_id(
+       cache: &ComponentCache,
+       component: &Component
+   ) -> Option<u32> {
+       let mut attrs = component.attributes.clone();
+       attrs.sort();  // Match cache key format
+       cache.get(&(component.name.clone(), attrs)).copied()
+   }
+   ```
+
+3. **Refresh** (on miss):
+   ```rust
+   async fn refresh_cache(client: &Client, url: &str) 
+       -> Result<ComponentCache> 
+   {
+       let components = fetch_components(client, url).await?;
+       Ok(build_component_id_cache(components))
+   }
+   ```
+
+**Lifecycle**:
+- **Created**: Reporter startup (with 3 retries, 60s delays per FR-006)
+- **Refreshed**: On cache miss during incident creation (1 attempt, per FR-005)
+- **Invalidated**: Never (components are stable; refresh only on miss)
+
+**Subset Matching** (FR-012):
+The cache stores full component attributes from the Status Dashboard. Config may specify fewer attributes:
+```rust
+// Config component
+Component { 
+    name: "Storage", 
+    attributes: vec![region=EU-DE] 
+}
+
+// Dashboard component (in cache)
+StatusDashboardComponent { 
+    id: 218, 
+    name: "Storage", 
+    attributes: vec![region=EU-DE, type=block] 
+}
+
+// Lookup fails because keys don't match exactly!
+// Solution: FR-012 specifies subset matching, but cache uses exact key matching.
+// Implementation must iterate cache to find subset matches.
+```
+
+**Corrected Lookup Algorithm** (for subset matching):
+```rust
+fn find_component_id(
+    cache: &ComponentCache,
+    target: &Component
+) -> Option<u32> {
+    cache.iter()
+        .filter(|((name, _attrs), _id)| name == &target.name)
+        .find(|((_name, cache_attrs), _id)| {
+            // Config attrs must be subset of cache attrs
+            target.attributes.iter().all(|target_attr| {
+                cache_attrs.iter().any(|cache_attr| {
+                    cache_attr.name == target_attr.name 
+                    && cache_attr.value == target_attr.value
+                })
+            })
+        })
+        .map(|((_name, _attrs), id)| *id)
+}
+```
+
+**Performance**: O(n) worst case where n = cache size (~100 components), acceptable for 60s monitoring intervals.
+
+---
+
+### 5. IncidentData (V2 API Request)
+
+**Purpose**: Represents the incident payload sent to Status Dashboard API V2 `/v2/incidents` endpoint.
+
+**Rust Definition**:
+```rust
+#[derive(Clone, Deserialize, Serialize, Debug)]
+pub struct IncidentData {
+    pub title: String,              // Static: "System incident from monitoring system"
+    #[serde(default)]
+    pub description: String,        // Static generic message (FR-017)
+    pub impact: u8,                 // 0=none, 1=minor, 2=major, 3=critical
+    pub components: Vec<u32>,       // Component IDs (resolved from cache)
+    pub start_date: DateTime<Utc>,  // Health metric timestamp - 1s (RFC3339)
+    #[serde(default)]
+    pub system: bool,               // Always true for auto-created incidents
+    #[serde(rename = "type")]
+    pub incident_type: String,      // Always "incident" for auto-created
+}
+```
+
+**JSON Representation** (POST request body):
+```json
+{
+  "title": "System incident from monitoring system",
+  "description": "System-wide incident affecting one or multiple components. Created automatically.",
+  "impact": 2,
+  "components": [218],
+  "start_date": "2025-01-22T10:30:44Z",
+  "system": true,
+  "type": "incident"
+}
+```
+
+**Field Mapping from Health Metric**:
+
+| Source | Field | Value | Transformation |
+|--------|-------|-------|----------------|
+| Health API | `timestamp` (i64) | Epoch seconds | `DateTime::from_timestamp(ts - 1, 0)` |
+| Health API | `impact` (u8) | 0-3 | Direct copy |
+| Config | Component name + attrs | "Storage", {region:EU-DE} | Resolve to component ID via cache |
+| Static | `title` | - | "System incident from monitoring system" |
+| Static | `description` | - | "System-wide incident..." |
+| Static | `system` | - | `true` |
+| Static | `incident_type` | - | `"incident"` |
+
+**Construction Logic**:
+```rust
+async fn build_incident_data(
+    service_health: &ServiceHealthData,
+    component_id: u32,
+) -> IncidentData {
+    let (timestamp, impact) = service_health.metrics.last().unwrap();
+    
+    let start_date = DateTime::<Utc>::from_timestamp(
+        *timestamp - 1,  // -1 second per FR-011
+        0
+    ).unwrap();
+    
+    IncidentData {
+        title: "System incident from monitoring system".to_string(),
+        description: "System-wide incident affecting one or multiple components. Created automatically.".to_string(),
+        impact: *impact,
+        components: vec![component_id],
+        start_date,
+        system: true,
+        incident_type: "incident".to_string(),
+    }
+}
+```
+
+**Validation Rules**:
+- `impact`: Must be in range [0, 3]
+- `components`: Non-empty array (at least one component ID)
+- `start_date`: Valid RFC3339 datetime
+- `type`: Must be `"incident"` (not `"maintenance"` or `"info"`)
+
+**API Response** (on success):
+```json
+{
+  "result": [
+    {
+      "component_id": 218,
+      "incident_id": 456  // Existing incident ID if duplicate, or new ID
+    }
+  ]
+}
+```
+
+**Relationships**:
+- **Created from**: `ServiceHealthResponse` (health API) + `Component` (config) + `ComponentCache` (ID lookup)
+- **Sent to**: Status Dashboard API `/v2/incidents`
+- **Security**: Generic title/description prevent exposing sensitive data (FR-017)
+
+---
+
+### 6. ServiceHealthResponse (Existing, unchanged)
+
+**Purpose**: Response from the local convertor API `/api/v1/health` containing service health metrics.
+
+**Rust Definition** (from `src/api/v1.rs`):
+```rust
+#[derive(Debug, Serialize, Deserialize)]
+pub struct ServiceHealthResponse {
+    pub name: String,              // Service name (e.g., "swift")
+    pub service_category: String,  // Category (e.g., "Storage")
+    pub environment: String,       // Environment name (e.g., "production")
+    pub metrics: ServiceHealthData,  // Health data points
+}
+
+pub type ServiceHealthData = Vec<(i64, u8)>;
+// Vec of (timestamp_epoch_seconds, impact_0_to_3)
+```
+
+**Example**:
+```json
+{
+  "name": "swift",
+  "service_category": "Storage",
+  "environment": "production",
+  "metrics": [
+    [1706000000, 0],
+    [1706000060, 0],
+    [1706000120, 2]  // Impact level 2 (major issue)
+  ]
+}
+```
+
+**Usage in Reporter**:
+```rust
+// Reporter queries convertor API
+let response: ServiceHealthResponse = req_client
+    .get("http://localhost:8080/api/v1/health")
+    .query(&[
+        ("environment", "production"),
+        ("service", "swift"),
+        ("from", "-5min"),
+        ("to", "-2min")
+    ])
+    .send().await?
+    .json().await?;
+
+// Check last metric
+if let Some((timestamp, impact)) = response.metrics.last() {
+    if *impact > 0 {
+        // Create incident using *impact and *timestamp
+    }
+}
+```
+
+**Relationships**:
+- **Source**: Local convertor API (unchanged by this migration)
+- **Consumed by**: Reporter's monitoring loop
+- **Used to create**: `IncidentData` when impact > 0
+
+---
+
+## Data Flow
+
+### Startup Flow
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│ 1. Reporter Startup                                             │
+└───────────────┬─────────────────────────────────────────────────┘
+                │
+                ▼
+┌─────────────────────────────────────────────────────────────────┐
+│ 2. Fetch Components (with retry)                                │
+│    GET /v2/components → Vec<StatusDashboardComponent>           │
+│    Retry: 3 attempts, 60s delay (FR-006)                        │
+└───────────────┬─────────────────────────────────────────────────┘
+                │
+                ▼
+┌─────────────────────────────────────────────────────────────────┐
+│ 3. Build Component Cache                                        │
+│    ComponentCache = HashMap<(name, attrs), id>                  │
+│    Sort attributes before inserting                             │
+└───────────────┬─────────────────────────────────────────────────┘
+                │
+                ▼
+┌─────────────────────────────────────────────────────────────────┐
+│ 4. Start Monitoring Loop                                        │
+│    Every 60 seconds                                             │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+### Incident Creation Flow
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│ 1. Query Health API                                             │
+│    GET /api/v1/health?env=prod&service=swift                    │
+│    Response: ServiceHealthResponse                              │
+└───────────────┬─────────────────────────────────────────────────┘
+                │
+                ▼
+┌─────────────────────────────────────────────────────────────────┐
+│ 2. Check Impact Level                                           │
+│    if metrics.last().impact > 0 { proceed }                     │
+└───────────────┬─────────────────────────────────────────────────┘
+                │
+                ▼
+┌─────────────────────────────────────────────────────────────────┐
+│ 3. Lookup Component ID                                          │
+│    component = config.get(service_name)                         │
+│    component_id = cache.find((component.name, component.attrs)) │
+└───────────────┬─────────────────────────────────────────────────┘
+                │
+          ┌─────┴─────┐
+          │           │
+    Found │           │ Not Found
+          ▼           ▼
+     ┌─────────┐  ┌────────────────────────────────┐
+     │ Create  │  │ Refresh Cache (1 attempt)      │
+     │Incident │  │ Retry lookup once (FR-005)     │
+     └────┬────┘  └──────────┬─────────────────────┘
+          │                  │
+          │         ┌────────┴────────┐
+          │   Found │                 │ Still Not Found
+          │         ▼                 ▼
+          │  ┌─────────────┐  ┌──────────────────┐
+          │  │   Create    │  │ Log Warning      │
+          │  │  Incident   │  │ Skip incident    │
+          │  └──────┬──────┘  │ Continue loop    │
+          │         │         └──────────────────┘
+          └─────────┴──────┐
+                           ▼
+┌─────────────────────────────────────────────────────────────────┐
+│ 4. Build IncidentData                                           │
+│    - title: static                                              │
+│    - description: static                                        │
+│    - impact: from health metric                                 │
+│    - components: [component_id]                                 │
+│    - start_date: timestamp - 1s (RFC3339)                       │
+│    - system: true                                               │
+│    - type: "incident"                                           │
+└───────────────┬─────────────────────────────────────────────────┘
+                │
+                ▼
+┌─────────────────────────────────────────────────────────────────┐
+│ 5. POST to /v2/events                                           │
+│    Authorization: Bearer <HMAC-JWT>                             │
+│    Body: IncidentData (JSON)                                    │
+│    Timeout: 2s                                                  │
+└───────────────┬─────────────────────────────────────────────────┘
+                │
+          ┌─────┴─────┐
+          │           │
+    Success│           │ Error
+          ▼           ▼
+     ┌─────────┐  ┌───────────────────────────┐
+     │Log INFO │  │ Log ERROR (status + body) │
+     │Continue │  │ Continue to next service  │
+     │to next  │  │ (retry in next cycle)     │
+     └─────────┘  └───────────────────────────┘
+```
+
+---
+
+## Entity Relationships Diagram
+
+```
+┌──────────────────────────────────────────────────────────────────┐
+│                         Configuration                            │
+│                        (config.yaml)                             │
+└────────────────┬─────────────────────────────────────────────────┘
+                 │
+                 │ Defines
+                 ▼
+┌────────────────────────────────┐      ┌───────────────────────┐
+│       Component (Config)       │      │  ComponentAttribute   │
+├────────────────────────────────┤      ├───────────────────────┤
+│ + name: String                 │◆─────│ + name: String        │
+│ + attributes: Vec<Attribute>   │1   * │ + value: String       │
+└────────────────┬───────────────┘      └───────────────────────┘
+                 │                                 ▲
+                 │ Lookup                          │
+                 ▼                                 │ Uses
+┌────────────────────────────────────────────┐    │
+│          ComponentCache                    │    │
+│   HashMap<(String, Vec<Attr>), u32>        │    │
+├────────────────────────────────────────────┤    │
+│ Key: (component_name, sorted_attributes)   │    │
+│ Value: component_id                        │    │
+└────────────────┬───────────────────────────┘    │
+                 ▲                                 │
+                 │ Built from                      │
+                 │                                 │
+┌────────────────┴───────────────┐                │
+│  StatusDashboardComponent      │                │
+│      (from API)                │◆───────────────┘
+├────────────────────────────────┤1              *
+│ + id: u32                      │
+│ + name: String                 │
+│ + attributes: Vec<Attribute>   │
+└────────────────────────────────┘
+         ▲
+         │ Fetched from
+         │
+┌────────┴──────────────────────────────────────────────────┐
+│     Status Dashboard API: GET /v2/components              │
+└───────────────────────────────────────────────────────────┘
+
+
+┌────────────────────────────────┐
+│   ServiceHealthResponse        │
+│   (from convertor API)         │
+├────────────────────────────────┤
+│ + name: String                 │
+│ + service_category: String     │
+│ + environment: String          │
+│ + metrics: Vec<(i64, u8)>      │  (timestamp, impact)
+└────────────────┬───────────────┘
+                 │
+                 │ impact > 0?
+                 ▼
+         ┌───────────────┐
+         │  Resolve via  │
+         │     Cache     │
+         └───────┬───────┘
+                 │
+                 ▼ component_id
+┌────────────────────────────────┐
+│        IncidentData            │
+│     (V2 API request)           │
+├────────────────────────────────┤
+│ + title: String                │
+│ + description: String          │
+│ + impact: u8                   │
+│ + components: Vec<u32>         │──── Resolved from cache
+│ + start_date: DateTime<Utc>   │──── From health metric (ts - 1s)
+│ + system: bool                 │──── Always true
+│ + incident_type: String        │──── Always "incident"
+└────────────────┬───────────────┘
+                 │
+                 │ POST
+                 ▼
+┌───────────────────────────────────────────────────────────┐
+│   Status Dashboard API: POST /v2/incidents                │
+└───────────────────────────────────────────────────────────┘
+```
+
+---
+
+## State Transitions
+
+### Component Cache States
+
+```
+[Uninitialized] 
+    │
+    │ Startup: fetch_components_with_retry()
+    │ Attempts: 3, Delay: 60s
+    │
+    ├── Success ──→ [Loaded]
+    │                  │
+    │                  │ Monitoring loop
+    │                  │ Cache miss?
+    │                  │
+    │                  ├── Yes ──→ refresh_cache() (1 attempt)
+    │                  │            │
+    │                  │            ├── Success ──→ [Loaded] (updated)
+    │                  │            │
+    │                  │            └── Fail ──→ [Stale] (log warning, continue)
+    │                  │
+    │                  └── No ──→ [Loaded] (continue)
+    │
+    └── Fail (after 3 retries) ──→ [Failed] (panic, reporter exits)
+```
+
+### Incident Creation States
+
+```
+[Monitoring] 
+    │
+    │ Query health API
+    │
+    ├── impact = 0 ──→ [No Action] (continue to next service)
+    │
+    └── impact > 0 ──→ [Resolving Component]
+                        │
+                        │ Lookup component_id in cache
+                        │
+                        ├── Found ──→ [Creating Incident]
+                        │              │
+                        │              │ POST /v2/incidents
+                        │              │
+                        │              ├── Success (200) ──→ [Incident Created]
+                        │              │                      │
+                        │              │                      └─→ Log INFO, continue
+                        │              │
+                        │              └── Fail (4xx/5xx/timeout) ──→ [Error]
+                        │                                              │
+                        │                                              └─→ Log ERROR, continue
+                        │                                                  (retry in next cycle)
+                        │
+                        └── Not Found ──→ [Refreshing Cache]
+                                          │
+                                          │ refresh_cache() (1 attempt)
+                                          │
+                                          ├── Found after refresh ──→ [Creating Incident]
+                                          │
+                                          └── Still not found ──→ [Component Missing]
+                                                                   │
+                                                                   └─→ Log WARNING, skip incident
+```
+
+---
+
+## Data Validation
+
+### Input Validation
+
+| Entity | Field | Validation | Error Handling |
+|--------|-------|------------|----------------|
+| `StatusDashboardComponent` | `id` | u32 > 0 | Serde deserialization error → log + skip |
+| `StatusDashboardComponent` | `name` | Non-empty string | Serde deserialization error → log + skip |
+| `ComponentAttribute` | `name` | Non-empty string | Serde deserialization error → log + skip |
+| `ComponentAttribute` | `value` | Non-empty string | Serde deserialization error → log + skip |
+| `IncidentData` | `impact` | 0 ≤ u8 ≤ 3 | Assert in code (from health metric, already validated) |
+| `IncidentData` | `components` | Non-empty Vec | Assert (only create incident if component_id found) |
+| `IncidentData` | `start_date` | Valid timestamp | chrono handles validation; panic if invalid |
+
+### Output Validation
+
+| Field | Constraint | Enforcement |
+|-------|-----------|-------------|
+| `IncidentData.title` | Static string | Hardcoded in code |
+| `IncidentData.description` | Static string | Hardcoded in code |
+| `IncidentData.system` | Always `true` | Hardcoded in code |
+| `IncidentData.incident_type` | Always `"incident"` | Hardcoded in code |
+| `IncidentData.start_date` | RFC3339 format | `chrono::DateTime::to_rfc3339()` |
+
+---
+
+## Security Considerations
+
+### Data Separation (FR-017)
+
+**Sensitive Data** (logged locally, NEVER sent to API):
+- Service name (e.g., "swift")
+- Environment name (e.g., "production")
+- Component name (e.g., "Object Storage Service")
+- Component attributes (e.g., `region=EU-DE`)
+- Triggered metric names (e.g., "latency_p95", "error_rate")
+- Metric values (e.g., "latency=450ms")
+
+**Public Data** (sent to Status Dashboard API):
+- Static generic title: "System incident from monitoring system"
+- Static generic description: "System-wide incident affecting one or multiple components. Created automatically."
+- Impact level (integer 0-3, no context)
+- Component IDs (integers, no names/attributes)
+- Start date (timestamp only, no context)
+
+**Rationale**: Status Dashboard is public-facing. Exposing service names, metric details, or specific component attributes would reveal internal infrastructure details.
+
+---
+
+## Performance Characteristics
+
+| Operation         | Complexity      | Frequency                        | Optimization          |
+|-------------------|-----------------|----------------------------------|-----------------------|
+| Cache build       | O(n log n)      | Once at startup + rare refreshes | Acceptable; n ~100    |
+| Component lookup  | O(n) worst case | Per incident (~1-10/min)         | Acceptable for n ~100 |
+| Incident creation | O(1)            | Per health issue (~1-10/min)     | HTTP timeout 2s       |
+| Health query      | O(1)            | Every 60s per service            | Existing, unchanged   |
+
+**Memory Usage**:
+- `ComponentCache`: ~100 entries × ~200 bytes/entry = ~20 KB
+- `StatusDashboardComponent` list: ~100 × ~200 bytes = ~20 KB (transient during cache build)
+- Negligible compared to reporter's base memory footprint (~10 MB)
+
+---
+
+## Testing Strategy
+
+### Unit Tests
+
+1. **Component Cache Building**:
+   - Test `build_component_id_cache()` with various attribute orders
+   - Verify attributes are sorted in cache keys
+   - Test empty attributes list
+
+2. **Component Matching**:
+   - Test exact match
+   - Test subset matching (config has fewer attributes)
+   - Test no match (different attribute values)
+   - Test no match (different component name)
+
+3. **Incident Data Construction**:
+   - Test timestamp adjustment (-1 second)
+   - Test RFC3339 formatting
+   - Test static field values
+
+### Integration Tests
+
+1. **Cache Load & Refresh**:
+   - Mock `/v2/components` endpoint
+   - Test successful cache load
+   - Test retry logic (3 attempts, 60s delays)
+   - Test cache refresh on miss
+
+2. **Incident Creation**:
+   - Mock `/v2/incidents` endpoint
+   - Test successful incident creation
+   - Test duplicate incident handling (API returns existing ID)
+   - Test error handling (4xx, 5xx, timeout)
+
+3. **End-to-End Flow**:
+   - Mock both convertor and Status Dashboard APIs
+   - Test full flow: health query → component lookup → incident creation
+   - Test cache miss → refresh → retry
+   - Test component not found → skip incident
+
+---
+
+## Summary
+
+This data model defines 6 core entities for the V2 migration:
+
+1. **ComponentAttribute**: Key-value pairs qualifying components
+2. **Component** (config): Reporter's view of components from config
+3. **StatusDashboardComponent**: API's view of components
+4. **ComponentCache**: In-memory mapping for efficient lookups
+5. **IncidentData**: V2 incident request payload
+6. **ServiceHealthResponse**: Existing health data (unchanged)
+
+Key design decisions:
+- **Cache structure**: HashMap with sorted attribute keys for deterministic lookups
+- **Subset matching**: Iterate cache to find components where config attrs ⊆ dashboard attrs
+- **Static incident fields**: Prevent exposing sensitive operational data on public dashboard
+- **Timestamp handling**: RFC3339 with -1 second adjustment per FR-011
+
+All entities align with OpenAPI schema and functional requirements (FR-001 through FR-017).
diff --git a/specs/003-sd-api-v2-migration/plan.md b/specs/003-sd-api-v2-migration/plan.md
new file mode 100644
index 0000000..4b76441
--- /dev/null
+++ b/specs/003-sd-api-v2-migration/plan.md
@@ -0,0 +1,340 @@
+# Implementation Plan: Status Dashboard API V2 Migration
+
+**Branch**: `003-sd-api-v2-migration` | **Date**: 2025-01-23 | **Spec**: [spec.md](spec.md)
+**Input**: Feature specification from `/specs/003-sd-api-v2-migration/spec.md`
+
+## Summary
+
+Migrate the `cloudmon-metrics-reporter` from Status Dashboard API V1 (`/v1/component_status`) to V2 (`/v2/events`, `/v2/components`). The migration introduces component ID caching with retry logic, restructures incident data with static title/description for security. Authorization mechanism (HMAC-JWT) remains unchanged. All 17 functional requirements (FR-001 through FR-017) are addressed through a nested HashMap cache structure with subset attribute matching, structured diagnostic logging separate from API payloads, and graceful error handling with automatic recovery.
+
+## Technical Context
+
+**Language/Version**: Rust 2021 edition (Cargo.toml: edition = "2021", likely Rust 1.70+)  
+**Primary Dependencies**: 
+- `reqwest ~0.11` (HTTP client with rustls-tls, json features)
+- `chrono ~0.4` (datetime handling, RFC3339 formatting)
+- `serde ~1.0` + `serde_json ~1.0` (JSON serialization)
+- `tokio ~1.42` (async runtime with full features)
+- `tracing ~0.1` + `tracing-subscriber ~0.3` (structured logging)
+- `jwt ~0.16`, `hmac ~0.12`, `sha2 ~0.10` (HMAC-JWT authentication)
+- **NEW**: `anyhow ~1.0` (for Result<T> error handling in cache functions)
+
+**Storage**: In-memory HashMap for component ID cache (~100 components × 200 bytes = ~20KB); no persistent storage  
+
+**Testing**: 
+- `cargo test` with `#[cfg(test)]` unit tests in source files
+- Integration tests in `tests/` directory using `mockito ~1.0`, `tokio-test`, `tower` utilities
+- Existing test files: `tests/integration_api.rs`, `tests/integration_health.rs`, `tests/documentation_validation.rs`
+
+**Target Platform**: Linux server (primary), macOS (development); binary target `cloudmon-metrics-reporter` from `src/bin/reporter.rs`
+
+**Project Type**: Single Rust project (library + 2 binaries: `cloudmon-metrics-convertor`, `cloudmon-metrics-reporter`)
+
+**Performance Goals**: 
+- API response time: <200ms p95 under normal load (100 concurrent requests per Constitution IV)
+- Metric conversion: <500ms for datasets up to 1000 data points
+- **Reporter-specific**: HTTP timeout 10s (increased from 2s per FR-014), monitoring cycle ~60s
+
+**Constraints**: 
+- Memory footprint: <100MB RSS under normal operation (Constitution IV)
+- Component cache refresh: 3 retries × 60s delays on startup (FR-006)
+- Incident creation: no immediate retry on failure, rely on 60s monitoring cycle (FR-015)
+
+**Scale/Scope**: 
+- ~100 components in Status Dashboard
+- ~10-20 monitored services per environment
+- ~1-10 incidents/minute under normal load
+- ~5000 lines of code in reporter binary (incremental change to existing)
+
+## Constitution Check
+
+*GATE: Must pass before Phase 0 research. Re-check after Phase 1 design.*
+
+### Principle I: Code Quality Standards
+
+| Requirement | Status | Compliance Notes |
+|-------------|--------|------------------|
+| Rust idiomatic practices | ✅ PASS | Uses standard collections (HashMap), serde for serialization, async/await patterns |
+| Documentation | ✅ PASS | Existing `reporter.rs` has doc comments; new functions will follow rustdoc conventions |
+| Type safety | ✅ PASS | Strong typing for all structs (ComponentAttribute, IncidentData); uses Result<T> for errors |
+| Error handling | ✅ PASS | Adding `anyhow::Result<T>` for cache functions; no `unwrap()` in production paths (only in main setup) |
+| Code review | ✅ PASS | Feature branch `003-sd-api-v2-migration` will undergo peer review before merge |
+
+### Principle II: Testing Excellence
+
+| Requirement | Status | Compliance Notes |
+|-------------|--------|------------------|
+| Unit test coverage | ✅ PASS | Plan includes unit tests for cache building, component matching, timestamp handling (target 95% per Constitution) |
+| Integration tests | ✅ PASS | Using `mockito` to mock `/v2/components` and `/v2/incidents` endpoints; testing full flow |
+| Contract testing | ✅ PASS | OpenAPI schema validation against `openapi.yaml`; contracts defined in `specs/003-sd-api-v2-migration/contracts/` |
+| Mock external dependencies | ✅ PASS | `mockito ~1.0` already in dev-dependencies for mocking Status Dashboard API |
+| Test organization | ✅ PASS | Unit tests in `#[cfg(test)]` modules; integration tests in `tests/reporter_v2_integration.rs` (new file) |
+
+### Principle III: User Experience Consistency
+
+| Requirement | Status | Compliance Notes |
+|-------------|--------|------------------|
+| API consistency | ✅ PASS | Reporter uses `serde_json` for consistent JSON handling; follows existing patterns |
+| Configuration interface | ✅ PASS | No config changes required (FR-008); existing YAML config remains compatible |
+| Logging standards | ✅ PASS | Uses `tracing` crate for structured logging; FR-017 adds diagnostic fields (timestamp, service, environment, component details, impact, triggered_metrics) |
+| CLI consistency | ✅ PASS | Reporter binary interface unchanged; existing `--help` and exit codes maintained |
+| Documentation coherence | ⚠️ DEFER | Will update `doc/` after implementation; migration documented in `specs/003-sd-api-v2-migration/quickstart.md` |
+
+### Principle IV: Performance Requirements
+
+| Requirement         | Status   | Compliance Notes                                                                                      |
+|---------------------|----------|-------------------------------------------------------------------------------------------------------|
+| Resource efficiency | ✅ PASS   | Component cache adds ~20KB memory (negligible); no heap allocation in hot paths                       |
+| Async operations    | ✅ PASS   | All I/O uses async/await with `tokio` runtime (existing pattern maintained)                           |
+| Query optimization  | ✅ PASS   | Component cache eliminates repeated API calls; cached lookup is O(n) for ~100 components (acceptable) |
+| Performance testing | ⚠️ DEFER | Benchmark tests for cache lookup optional (not in hot path); integration tests cover timeout behavior |
+
+### Development Workflow
+
+| Requirement | Status | Compliance Notes |
+|-------------|--------|------------------|
+| Branch strategy | ✅ PASS | Feature branch `003-sd-api-v2-migration` already exists |
+| Pre-commit checks | ✅ PASS | `.pre-commit-config.yaml` configured; will run `cargo fmt`, `cargo clippy` |
+| CI/CD gates | ✅ PASS | Existing Zuul pipeline runs `cargo build`, `cargo clippy`, `cargo test`, Docker build |
+| Review requirements | ✅ PASS | PR will require maintainer approval verifying Constitution compliance |
+
+**Overall Assessment**: ✅ **PASS** - All critical gates pass. Two items deferred to post-implementation (documentation updates, optional benchmarks) are acceptable per Constitution governance.
+
+**Re-check After Phase 1**: Will verify test coverage meets 95% target for new code, structured logging includes all FR-017 diagnostic fields.
+
+## Project Structure
+
+### Documentation (this feature)
+
+```text
+specs/003-sd-api-v2-migration/
+├── spec.md                     # Feature specification (17 FRs, 3 user stories)
+├── plan.md                     # This file - implementation plan
+├── research.md                 # Phase 0: Technology decisions, API analysis, cache design
+├── data-model.md               # Phase 1: Entity definitions, relationships, flows
+├── quickstart.md               # Phase 1: Step-by-step implementation guide
+├── contracts/                  # Phase 1: API contract specifications
+│   ├── README.md               # Contract overview and usage
+│   ├── components-api.md       # GET /v2/components endpoint spec
+│   ├── incidents-api.md        # POST /v2/incidents endpoint spec
+│   ├── request-examples/       # Sample JSON request payloads
+│   │   ├── create-incident-single-component.json
+│   │   └── create-incident-multi-component.json
+│   └── response-examples/      # Sample JSON response payloads
+│       ├── components-list.json
+│       └── incident-created.json
+└── tasks.md                    # Phase 2: Generated by /speckit.tasks (NOT by /speckit.plan)
+```
+
+### Source Code (repository root)
+
+```text
+src/
+├── bin/
+│   ├── convertor.rs           # Unchanged - metric conversion binary
+│   └── reporter.rs            # ✏️  MODIFIED - V2 API migration implementation
+├── api/
+│   └── v1.rs                  # Unchanged - health API (ServiceHealthResponse used by reporter)
+├── api.rs                     # Unchanged - API router
+├── common.rs                  # Unchanged - shared utilities
+├── config.rs                  # Unchanged - config parsing (no config changes needed)
+├── graphite.rs                # Unchanged - TSDB backend
+├── lib.rs                     # Unchanged - library root
+└── types.rs                   # Unchanged - core type definitions
+
+tests/
+├── integration_api.rs         # Existing - API integration tests
+├── integration_health.rs      # Existing - health endpoint tests
+├── documentation_validation.rs # Existing - doc validation
+└── reporter_v2_integration.rs # ✨ NEW - V2 migration integration tests
+    # Tests: component fetching, cache building, incident creation, error handling
+
+Cargo.toml                     # ✏️  MODIFIED - add anyhow ~1.0 dependency
+openapi.yaml                   # Reference - Status Dashboard API V2 contract source
+```
+
+**Structure Decision**: Single Rust project with library + binaries. This migration only modifies `src/bin/reporter.rs` (adds ~300 lines for cache management and V2 API calls) and adds one new integration test file. No changes to project structure needed - follows existing patterns for binary implementations in `src/bin/` and integration tests in `tests/`.
+
+**Modified Files**:
+1. **`Cargo.toml`**: Add `anyhow = "~1.0"` dependency for Result error handling
+2. **`src/bin/reporter.rs`**: 
+   - Add structs: `StatusDashboardComponent`, `IncidentData`
+   - Update `ComponentAttribute` derives (add `PartialOrd`, `Ord`, `Hash`)
+   - Add functions: `fetch_components*`, `build_component_id_cache`, `find_component_id`, `build_incident_data`, `create_incident`
+   - Update `metric_watcher`: load cache at startup, replace V1 endpoint with V2, add cache miss handling
+
+**New Files**:
+3. **`tests/reporter_v2_integration.rs`**: Integration tests using `mockito` to mock Status Dashboard V2 endpoints
+
+## Complexity Tracking
+
+*No Constitution violations identified. This section intentionally left empty per template instructions.*
+
+**Rationale**: All implementation decisions align with Constitution principles:
+- **Simple cache structure**: Standard Rust HashMap (no custom abstractions)
+- **Subset matching**: O(n) iteration acceptable for n~100 components
+- **Error handling**: `anyhow::Result` is idiomatic Rust pattern
+- **No new architectural patterns**: Follows existing reporter structure
+- **Testing strategy**: Matches project's existing mockito + tokio-test approach
+
+---
+
+## Phase 0: Research (COMPLETED)
+
+**Status**: ✅ Complete - See [`research.md`](research.md)
+
+**Key Decisions Made**:
+1. **Component Cache**: Nested HashMap with sorted attributes for deterministic keys
+2. **V2 Incident Payload**: Static title/description, generic content (security per FR-017)
+3. **Error Handling**: 3x retry on startup (FR-006), single refresh on miss (FR-005), no immediate retry on incident creation (FR-015)
+4. **Testing**: mockito for API mocking, tokio-test for async tests
+5. **Authorization**: HMAC-JWT unchanged (FR-008)
+6. **Timestamp Handling**: RFC3339 with -1 second adjustment (FR-011)
+
+**All Technical Unknowns Resolved**: No "NEEDS CLARIFICATION" items remain.
+
+---
+
+## Phase 1: Design & Contracts (COMPLETED)
+
+**Status**: ✅ Complete - See design artifacts below
+
+### 1. Data Model
+**File**: [`data-model.md`](data-model.md)
+
+**Core Entities Defined**:
+- `ComponentAttribute`: Key-value pairs with sorting/hashing support
+- `Component` (config): Reporter's view from configuration
+- `StatusDashboardComponent` (API): Status Dashboard's view from `/v2/components`
+- `ComponentCache`: HashMap mapping (name, attrs) → component_id
+- `IncidentData`: V2 incident request payload with static security-compliant fields
+- `ServiceHealthResponse`: Existing, unchanged health metric structure
+
+**Key Diagrams**:
+- Entity relationship diagram showing data flow
+- State transition diagrams for cache and incident creation
+- Startup flow: component fetch → cache build → monitoring loop
+- Incident creation flow: health query → component lookup → cache refresh on miss → incident POST
+
+### 2. API Contracts
+**Directory**: [`contracts/`](contracts/)
+
+**Files Created**:
+- `contracts/README.md`: Contract overview and usage guide
+- `contracts/components-api.md`: GET /v2/components specification with Rust implementation examples
+- `contracts/incidents-api.md`: POST /v2/incidents specification with field constraints (FR-002, FR-017)
+- `contracts/request-examples/*.json`: Sample incident creation payloads
+- `contracts/response-examples/*.json`: Sample API responses (components list, incident created)
+
+**Validation**: All contracts derived from `/openapi.yaml` (project root, lines 138-270)
+
+### 3. Quickstart Guide
+**File**: [`quickstart.md`](quickstart.md)
+
+**Contents**:
+- Prerequisites (dependencies, Status Dashboard setup, config compatibility)
+- Step-by-step implementation (6 steps: structs, fetch, cache, lookup, incident, metric_watcher update)
+- Complete code examples with inline comments
+- Unit test suite (cache building, component matching)
+- Integration test suite (API mocking with mockito)
+- Verification procedures (logs to check, expected outputs)
+- Troubleshooting guide (common errors and solutions)
+
+### 4. Agent Context Update
+**Status**: ✅ Complete
+
+**Updated File**: `.github/agents/copilot-instructions.md`
+
+**Changes**: Added project-specific context about this feature (database: N/A, project type: single)
+
+---
+
+## Phase 2: Task Generation (DEFERRED)
+
+**Status**: ⏸️  Deferred to `/speckit.tasks` command
+
+**Rationale**: Per plan template instructions, `tasks.md` is generated by a separate command after Phase 1 design is complete. Implementation tasks will be created from:
+- Data model entities → implementation tickets
+- API contracts → integration test tickets
+- Quickstart steps → development workflow tickets
+
+**Next Command**: Run `/speckit.tasks` to generate actionable task breakdown with dependency ordering.
+
+---
+
+## Implementation Summary
+
+### Artifacts Generated
+
+| Phase | Artifact | Status | Lines | Description |
+|-------|----------|--------|-------|-------------|
+| 0 | `research.md` | ✅ Complete | 308 | Technology decisions, API analysis, cache design rationale |
+| 1 | `data-model.md` | ✅ Complete | 650+ | Entity definitions, relationships, data flows, state machines |
+| 1 | `contracts/components-api.md` | ✅ Complete | 250+ | GET /v2/components contract with Rust examples |
+| 1 | `contracts/incidents-api.md` | ✅ Complete | 500+ | POST /v2/incidents contract with FR-017 security notes |
+| 1 | `contracts/request-examples/` | ✅ Complete | 2 files | JSON request payload samples |
+| 1 | `contracts/response-examples/` | ✅ Complete | 2 files | JSON response payload samples |
+| 1 | `quickstart.md` | ✅ Complete | 800+ | Step-by-step implementation guide with code |
+| 1 | `.github/agents/copilot-instructions.md` | ✅ Updated | N/A | Agent context with project details |
+
+**Total Documentation**: ~2,500 lines of design artifacts + code examples
+
+### Key Design Decisions Captured
+
+1. **Cache Architecture** (research.md § 1):
+   - Nested HashMap<(String, Vec<Attr>), u32>
+   - Sorted attributes for deterministic keys
+   - Subset matching via iteration (O(n) acceptable for n~100)
+
+2. **Security Model** (data-model.md § 5, contracts/incidents-api.md § FR-017):
+   - Sensitive data (service names, environments, metric details) logged locally only
+   - Public data (generic title/description, impact level, component IDs) sent to API
+   - Clear separation documented in contracts and quickstart
+
+3. **Error Resilience** (research.md § 5, data-model.md § "State Transitions"):
+   - Startup: 3 retries × 60s delays, panic if cache load fails
+   - Runtime: single cache refresh on miss, log warning if still not found
+   - Incident creation: log error and continue, rely on next cycle (no immediate retry)
+
+4. **Testing Strategy** (quickstart.md § "Testing"):
+   - Unit tests: cache building, subset matching, timestamp handling
+   - Integration tests: mockito for API mocking, end-to-end flow validation
+   - Contract tests: OpenAPI schema validation (manual in staging)
+
+### Constitution Re-Check (Post-Design)
+
+**Status**: ✅ **PASS** - All principles maintained
+
+| Principle           | Re-Check Result                                                                |
+|---------------------|--------------------------------------------------------------------------------|
+| I. Code Quality     | ✅ Rust-idiomatic design, strong typing, proper error handling (anyhow::Result) |
+| II. Testing         | ✅ Comprehensive unit + integration tests planned (95% coverage target)         |
+| III. UX Consistency | ✅ Structured logging with FR-017 diagnostic fields, no config changes          |
+| IV. Performance     | ✅ Component cache adds ~20KB, O(n) lookup acceptable                           |
+
+**No new violations introduced.** Design maintains project's existing architectural patterns.
+
+---
+
+## Next Steps
+
+1. **Run** `/speckit.tasks` **command** to generate task breakdown from this plan
+2. **Review** generated `tasks.md` for task dependencies and estimation
+3. **Begin implementation** following `quickstart.md` step-by-step guide
+4. **Reference** `data-model.md` for entity structures during coding
+5. **Validate** against `contracts/*.md` during API integration
+6. **Execute tests** per `quickstart.md` § Testing section
+7. **Update** project documentation in `doc/` after implementation
+
+---
+
+## References
+
+- **Feature Spec**: [`spec.md`](spec.md) - 17 functional requirements, 3 user stories, edge cases
+- **OpenAPI Schema**: `/openapi.yaml` (project root) - Status Dashboard API V2 source of truth
+- **Reference Implementation**: `sd_api_v2_migration` branch - working V2 implementation for validation
+- **Constitution**: `.specify/memory/constitution.md` - CloudMon Metrics Processor principles
+- **Codebase**:
+  - Current reporter: `src/bin/reporter.rs`
+  - Health API types: `src/api/v1.rs` (ServiceHealthResponse)
+  - Test fixtures: `tests/fixtures/`
diff --git a/specs/003-sd-api-v2-migration/quickstart.md b/specs/003-sd-api-v2-migration/quickstart.md
new file mode 100644
index 0000000..51f1389
--- /dev/null
+++ b/specs/003-sd-api-v2-migration/quickstart.md
@@ -0,0 +1,721 @@
+# Quickstart: Status Dashboard API V2 Migration
+
+**Feature**: Reporter Migration to Status Dashboard API V2  
+**Branch**: `003-sd-api-v2-migration`  
+**Date**: 2025-01-23
+
+## Overview
+
+This guide provides a quickstart for implementing the Status Dashboard API V2 migration. The migration replaces the V1 component status endpoint with V2 incident creation and adds component ID caching.
+
+**Key Changes**:
+- ✅ Component ID cache at startup (with retry)
+- ✅ New incident structure with static title/description
+- ✅ Structured diagnostic logging (not sent to API)
+- ✅ Authorization unchanged (HMAC-JWT)
+
+---
+
+## Prerequisites
+
+### 1. Dependencies
+
+Add `anyhow` crate for error handling:
+
+```toml
+# Cargo.toml
+[dependencies]
+anyhow = "~1.0"
+chrono = "~0.4"  # Already present
+serde = { version = "~1.0", features = ["derive"] }  # Already present
+serde_json = "~1.0"  # Already present
+reqwest = { version = "~0.11", default-features = false, features = ["rustls-tls", "json"] }  # Already present
+```
+
+### 2. Status Dashboard Requirements
+
+- Status Dashboard must be running with V2 API endpoints available
+- All monitored components must be registered in Status Dashboard
+- Component names and attributes in config must match Status Dashboard exactly (or be subsets)
+
+### 3. Configuration
+
+No configuration changes required. Existing `config.yaml` is compatible:
+
+```yaml
+status_dashboard:
+  url: "https://status-dashboard.example.com"
+  secret: "your-hmac-secret"  # Optional, for auth
+
+environments:
+  - name: production
+    attributes:
+      region: "EU-DE"
+      category: "Storage"
+
+health_metrics:
+  swift:
+    component_name: "Object Storage Service"
+    # ... other health metric config
+```
+
+---
+
+## Implementation Steps
+
+### Step 1: Define Data Structures
+
+The Status Dashboard integration is consolidated in `src/sd.rs` library module. Add/update these structs:
+
+```rust
+// src/sd.rs - Status Dashboard integration module
+
+use anyhow;
+use hmac::{Hmac, Mac};
+use jwt::SignWithKey;
+use reqwest::header::HeaderMap;
+use serde::{Deserialize, Serialize};
+use sha2::Sha256;
+use std::collections::{BTreeMap, HashMap};
+
+// Update ComponentAttribute to support sorting and hashing
+#[derive(Clone, Deserialize, Serialize, Debug, PartialEq, Eq, Hash, Ord, PartialOrd)]
+pub struct ComponentAttribute {
+    pub name: String,
+    pub value: String,
+}
+
+// Existing Component struct (no changes needed)
+#[derive(Clone, Deserialize, Serialize, Debug)]
+pub struct Component {
+    pub name: String,
+    pub attributes: Vec<ComponentAttribute>,
+}
+
+// NEW: API response from GET /v2/components
+#[derive(Clone, Deserialize, Serialize, Debug)]
+pub struct StatusDashboardComponent {
+    pub id: u32,
+    pub name: String,
+    #[serde(default)]
+    pub attributes: Vec<ComponentAttribute>,
+}
+
+// NEW: API request for POST /v2/incidents
+#[derive(Clone, Deserialize, Serialize, Debug)]
+pub struct IncidentData {
+    pub title: String,
+    #[serde(default)]
+    pub description: String,
+    pub impact: u8,
+    pub components: Vec<u32>,
+    pub start_date: DateTime<Utc>,
+    #[serde(default)]
+    pub system: bool,
+    #[serde(rename = "type")]
+    pub incident_type: String,
+}
+
+// Component ID cache type
+type ComponentCache = HashMap<(String, Vec<ComponentAttribute>), u32>;
+```
+
+### Step 2: Implement Component Fetching
+
+```rust
+/// Fetch components from Status Dashboard API
+async fn fetch_components(
+    req_client: &reqwest::Client,
+    components_url: &str,
+) -> Result<Vec<StatusDashboardComponent>> {
+    let response = req_client.get(components_url).send().await?;
+    response.error_for_status_ref()?;
+    let components = response.json::<Vec<StatusDashboardComponent>>().await?;
+    Ok(components)
+}
+
+/// Fetch components with retry logic (3 attempts, 60s delays)
+async fn fetch_components_with_retry(
+    req_client: &reqwest::Client,
+    components_url: &str,
+) -> Option<Vec<StatusDashboardComponent>> {
+    let mut attempts = 0;
+    loop {
+        match fetch_components(req_client, components_url).await {
+            Ok(components) => {
+                tracing::info!("Successfully fetched {} components.", components.len());
+                return Some(components);
+            }
+            Err(e) => {
+                attempts += 1;
+                tracing::error!("Failed to fetch components (attempt {}/3): {}", attempts, e);
+                if attempts >= 3 {
+                    tracing::error!("Could not fetch components after 3 attempts. Giving up.");
+                    return None;
+                }
+                tracing::info!("Retrying in 60 seconds...");
+                sleep(Duration::from_secs(60)).await;
+            }
+        }
+    }
+}
+```
+
+### Step 3: Implement Cache Building
+
+```rust
+/// Build component ID cache from fetched components
+fn build_component_id_cache(
+    components: Vec<StatusDashboardComponent>,
+) -> ComponentCache {
+    components
+        .into_iter()
+        .map(|c| {
+            let mut attrs = c.attributes;
+            attrs.sort();  // Ensure deterministic cache keys
+            ((c.name, attrs), c.id)
+        })
+        .collect()
+}
+
+/// Update cache (with optional retry on startup)
+async fn update_component_cache(
+    req_client: &reqwest::Client,
+    components_url: &str,
+    with_retry: bool,
+) -> Result<ComponentCache> {
+    tracing::info!("Updating component cache...");
+
+    let fetch_future = if with_retry {
+        fetch_components_with_retry(req_client, components_url).await
+    } else {
+        fetch_components(req_client, components_url).await.ok()
+    };
+
+    match fetch_future {
+        Some(components) if !components.is_empty() => {
+            let cache = build_component_id_cache(components);
+            tracing::info!("Successfully updated component cache. New size: {}", cache.len());
+            Ok(cache)
+        }
+        Some(_) => {
+            anyhow::bail!("Component list from status-dashboard is empty.")
+        }
+        None => anyhow::bail!("Failed to fetch component list from status-dashboard."),
+    }
+}
+```
+
+### Step 4: Implement Component Lookup with Subset Matching
+
+```rust
+/// Find component ID in cache with subset attribute matching
+fn find_component_id(
+    cache: &ComponentCache,
+    target: &Component,
+) -> Option<u32> {
+    // Iterate cache to find matching component
+    cache.iter()
+        .filter(|((name, _attrs), _id)| name == &target.name)
+        .find(|((_name, cache_attrs), _id)| {
+            // Config attrs must be subset of cache attrs (FR-012)
+            target.attributes.iter().all(|target_attr| {
+                cache_attrs.iter().any(|cache_attr| {
+                    cache_attr.name == target_attr.name 
+                    && cache_attr.value == target_attr.value
+                })
+            })
+        })
+        .map(|((_name, _attrs), id)| *id)
+}
+```
+
+### Step 5: Implement Incident Creation
+
+```rust
+/// Build incident data from health metric
+fn build_incident_data(
+    component_id: u32,
+    impact: u8,
+    timestamp: i64,
+) -> IncidentData {
+    // Adjust timestamp by -1 second per FR-011
+    let start_date = DateTime::<Utc>::from_timestamp(timestamp - 1, 0)
+        .expect("Invalid timestamp");
+    
+    IncidentData {
+        title: "System incident from monitoring system".to_string(),
+        description: "System-wide incident affecting one or multiple components. Created automatically.".to_string(),
+        impact,
+        components: vec![component_id],
+        start_date,
+        system: true,
+        incident_type: "incident".to_string(),
+    }
+}
+
+/// Create incident via API
+async fn create_incident(
+    req_client: &reqwest::Client,
+    incidents_url: &str,
+    headers: &HeaderMap,
+    incident: &IncidentData,
+) -> Result<()> {
+    let response = req_client
+        .post(incidents_url)
+        .headers(headers.clone())
+        .json(incident)
+        .send()
+        .await?;
+    
+    if !response.status().is_success() {
+        let status = response.status();
+        let body = response.text().await?;
+        tracing::error!("Incident creation failed [{}]: {}", status, body);
+        return Err(anyhow::anyhow!("API error: {} - {}", status, body));
+    }
+    
+    tracing::info!("Incident created successfully");
+    Ok(())
+}
+```
+
+### Step 6: Update metric_watcher Function
+
+Replace the monitoring loop in `metric_watcher()`:
+
+```rust
+async fn metric_watcher(config: &Config) {
+    tracing::info!("Starting metric reporter thread");
+    
+    let req_client: reqwest::Client = ClientBuilder::new()
+        .timeout(Duration::from_secs(2))
+        .build()
+        .unwrap();
+    
+    // Build component lookup table from config (unchanged)
+    let mut components_from_config: HashMap<String, HashMap<String, Component>> = HashMap::new();
+    for env in config.environments.iter() {
+        // ... existing component building logic ...
+    }
+    
+    // Status Dashboard configuration
+    let sdb_config = config
+        .status_dashboard
+        .as_ref()
+        .expect("Status dashboard section is missing");
+    
+    // NEW: V2 endpoints
+    let components_url = format!("{}/v2/components", sdb_config.url);
+    let incidents_url = format!("{}/v2/incidents", sdb_config.url);
+    
+    // Setup authorization headers (unchanged)
+    let mut headers = HeaderMap::new();
+    if let Some(ref secret) = sdb_config.secret {
+        let key: Hmac<Sha256> = Hmac::new_from_slice(secret.as_bytes()).unwrap();
+        let mut claims = BTreeMap::new();
+        claims.insert("stackmon", "dummy");
+        let token_str = claims.sign_with_key(&key).unwrap();
+        let bearer = format!("Bearer {}", token_str);
+        headers.insert(AUTHORIZATION, bearer.parse().unwrap());
+    }
+    
+    // NEW: Load component cache at startup with retry (FR-006, FR-007)
+    let mut component_cache = update_component_cache(&req_client, &components_url, true)
+        .await
+        .expect("Failed to load component cache. Reporter cannot start.");
+    
+    tracing::info!("Component cache loaded with {} entries", component_cache.len());
+    
+    // Monitoring loop
+    loop {
+        for env in config.environments.iter() {
+            for (service_name, _component_config) in config.health_metrics.iter() {
+                // Query health API (unchanged)
+                match req_client
+                    .get(format!("http://localhost:{}/api/v1/health", config.server.port))
+                    .query(&[
+                        ("environment", env.name.clone()),
+                        ("service", service_name.clone()),
+                        ("from", "-5min".to_string()),
+                        ("to", "-2min".to_string()),
+                    ])
+                    .send()
+                    .await
+                {
+                    Ok(rsp) => {
+                        if rsp.status().is_client_error() {
+                            tracing::error!("Got API error {:?}", rsp.text().await);
+                        } else {
+                            match rsp.json::<ServiceHealthResponse>().await {
+                                Ok(mut data) => {
+                                    if let Some((timestamp, impact)) = data.metrics.pop() {
+                                        if impact > 0 {
+                                            // Get component from config
+                                            let component = components_from_config
+                                                .get(&env.name)
+                                                .and_then(|env_map| env_map.get(service_name))
+                                                .expect("Component not found in config");
+                                            
+                                            // NEW: Look up component ID in cache
+                                            let component_id = match find_component_id(&component_cache, component) {
+                                                Some(id) => id,
+                                                None => {
+                                                    // Cache miss: refresh and retry (FR-005)
+                                                    tracing::warn!("Component not found in cache: {} {:?}", component.name, component.attributes);
+                                                    tracing::info!("Refreshing component cache...");
+                                                    
+                                                    match update_component_cache(&req_client, &components_url, false).await {
+                                                        Ok(new_cache) => {
+                                                            component_cache = new_cache;
+                                                            match find_component_id(&component_cache, component) {
+                                                                Some(id) => id,
+                                                                None => {
+                                                                    tracing::warn!("Component still not found after cache refresh: {} {:?}", component.name, component.attributes);
+                                                                    continue;  // Skip incident creation
+                                                                }
+                                                            }
+                                                        }
+                                                        Err(e) => {
+                                                            tracing::error!("Failed to refresh cache: {}", e);
+                                                            continue;  // Skip incident creation
+                                                        }
+                                                    }
+                                                }
+                                            };
+                                            
+                                            // NEW: Log diagnostic details (FR-017)
+                                            tracing::info!(
+                                                timestamp = timestamp,
+                                                service = %service_name,
+                                                environment = %env.name,
+                                                component_name = %component.name,
+                                                component_attrs = ?component.attributes,
+                                                component_id = component_id,
+                                                impact = impact,
+                                                "Creating incident for health issue"
+                                            );
+                                            
+                                            // NEW: Build and create incident
+                                            let incident = build_incident_data(component_id, impact, timestamp);
+                                            
+                                            match create_incident(&req_client, &incidents_url, &headers, &incident).await {
+                                                Ok(_) => {
+                                                    tracing::info!("Incident reported successfully");
+                                                }
+                                                Err(e) => {
+                                                    tracing::error!("Failed to create incident: {}", e);
+                                                    // Continue to next service (FR-015)
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                Err(e) => {
+                                    tracing::error!("Cannot process response: {}", e);
+                                }
+                            }
+                        }
+                    }
+                    Err(e) => {
+                        tracing::error!("Error querying health API: {}", e);
+                    }
+                }
+            }
+        }
+        
+        // Sleep between monitoring cycles
+        sleep(Duration::from_secs(60)).await;
+    }
+}
+```
+
+---
+
+## Testing
+
+### Unit Tests
+
+Add to `src/bin/reporter.rs`:
+
+```rust
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_build_component_id_cache() {
+        let components = vec![
+            StatusDashboardComponent {
+                id: 218,
+                name: "Storage".to_string(),
+                attributes: vec![
+                    ComponentAttribute { name: "region".to_string(), value: "EU-DE".to_string() },
+                    ComponentAttribute { name: "category".to_string(), value: "Storage".to_string() },
+                ],
+            },
+        ];
+        
+        let cache = build_component_id_cache(components);
+        
+        // Attributes should be sorted in cache key
+        let key = (
+            "Storage".to_string(),
+            vec![
+                ComponentAttribute { name: "category".to_string(), value: "Storage".to_string() },
+                ComponentAttribute { name: "region".to_string(), value: "EU-DE".to_string() },
+            ],
+        );
+        
+        assert_eq!(cache.get(&key), Some(&218));
+    }
+
+    #[test]
+    fn test_find_component_id_exact_match() {
+        let mut cache = ComponentCache::new();
+        cache.insert(
+            (
+                "Storage".to_string(),
+                vec![ComponentAttribute { name: "region".to_string(), value: "EU-DE".to_string() }],
+            ),
+            218,
+        );
+        
+        let component = Component {
+            name: "Storage".to_string(),
+            attributes: vec![ComponentAttribute { name: "region".to_string(), value: "EU-DE".to_string() }],
+        };
+        
+        assert_eq!(find_component_id(&cache, &component), Some(218));
+    }
+
+    #[test]
+    fn test_find_component_id_subset_match() {
+        let mut cache = ComponentCache::new();
+        cache.insert(
+            (
+                "Storage".to_string(),
+                vec![
+                    ComponentAttribute { name: "category".to_string(), value: "Storage".to_string() },
+                    ComponentAttribute { name: "region".to_string(), value: "EU-DE".to_string() },
+                ],
+            ),
+            218,
+        );
+        
+        // Config has only region (subset of cache)
+        let component = Component {
+            name: "Storage".to_string(),
+            attributes: vec![ComponentAttribute { name: "region".to_string(), value: "EU-DE".to_string() }],
+        };
+        
+        assert_eq!(find_component_id(&cache, &component), Some(218));
+    }
+
+    #[test]
+    fn test_find_component_id_no_match() {
+        let mut cache = ComponentCache::new();
+        cache.insert(
+            ("Storage".to_string(), vec![]),
+            218,
+        );
+        
+        let component = Component {
+            name: "Compute".to_string(),
+            attributes: vec![],
+        };
+        
+        assert_eq!(find_component_id(&cache, &component), None);
+    }
+}
+```
+
+### Integration Tests
+
+Create `tests/reporter_v2_integration.rs`:
+
+```rust
+use mockito::{Mock, Server};
+use cloudmon_metrics::config::Config;
+
+#[tokio::test]
+async fn test_fetch_components_success() {
+    let mut server = Server::new_async().await;
+    
+    let mock = server.mock("GET", "/v2/components")
+        .with_status(200)
+        .with_header("content-type", "application/json")
+        .with_body(r#"[
+            {
+                "id": 218,
+                "name": "Storage",
+                "attributes": [{"name": "region", "value": "EU-DE"}]
+            }
+        ]"#)
+        .create_async()
+        .await;
+    
+    let client = reqwest::Client::new();
+    let url = format!("{}/v2/components", server.url());
+    
+    let components = fetch_components(&client, &url).await.unwrap();
+    
+    assert_eq!(components.len(), 1);
+    assert_eq!(components[0].id, 218);
+    mock.assert_async().await;
+}
+
+#[tokio::test]
+async fn test_create_incident_success() {
+    let mut server = Server::new_async().await;
+    
+    let mock = server.mock("POST", "/v2/incidents")
+        .with_status(200)
+        .with_header("content-type", "application/json")
+        .with_body(r#"{"result": [{"component_id": 218, "incident_id": 456}]}"#)
+        .create_async()
+        .await;
+    
+    let client = reqwest::Client::new();
+    let url = format!("{}/v2/incidents", server.url());
+    let headers = HeaderMap::new();
+    
+    let incident = IncidentData {
+        title: "Test".to_string(),
+        description: "Test".to_string(),
+        impact: 2,
+        components: vec![218],
+        start_date: chrono::Utc::now(),
+        system: true,
+        incident_type: "incident".to_string(),
+    };
+    
+    let result = create_incident(&client, &url, &headers, &incident).await;
+    
+    assert!(result.is_ok());
+    mock.assert_async().await;
+}
+```
+
+Run tests:
+```bash
+cargo test
+```
+
+---
+
+## Verification
+
+### 1. Check Component Cache Loading
+
+Start the reporter and verify logs:
+
+```bash
+RUST_LOG=info cargo run --bin cloudmon-metrics-reporter
+```
+
+Expected output:
+```
+INFO Updating component cache...
+INFO Successfully fetched 100 components.
+INFO Successfully updated component cache. New size: 100
+INFO Component cache loaded with 100 entries
+INFO Starting metric reporter thread
+```
+
+### 2. Trigger an Incident
+
+Create a health issue and check logs:
+
+```
+INFO Creating incident for health issue timestamp=1706000120 service="swift" environment="production" component_name="Object Storage Service" component_attrs=[ComponentAttribute { name: "region", value: "EU-DE" }] component_id=218 impact=2
+INFO Incident created successfully
+INFO Incident reported successfully
+```
+
+### 3. Verify in Status Dashboard
+
+Check Status Dashboard UI:
+- Incident should appear with title "System incident from monitoring system"
+- `system` flag should be true
+- Impact level should match health metric
+- Component should be correctly associated
+
+### 4. Test Cache Refresh
+
+1. Add a new component to Status Dashboard
+2. Update config to reference new component
+3. Trigger health issue for new component
+4. Verify logs show cache refresh:
+
+```
+WARN Component not found in cache: "New Service" [...]
+INFO Refreshing component cache...
+INFO Successfully updated component cache. New size: 101
+INFO Creating incident for health issue ... component_id=350 ...
+```
+
+---
+
+## Troubleshooting
+
+### Issue: "Failed to load component cache. Reporter cannot start."
+
+**Cause**: Cannot fetch components from Status Dashboard (network error, auth issue, or API unavailable)
+
+**Solution**:
+1. Check Status Dashboard URL in config
+2. Verify Status Dashboard is running and `/v2/components` endpoint is accessible
+3. Check authentication secret if configured
+4. Review logs for specific error messages
+
+### Issue: "Component not found in cache" (repeated)
+
+**Cause**: Component name or attributes in config don't match Status Dashboard
+
+**Solution**:
+1. Check component name spelling in config
+2. Verify attributes match exactly (or are subset of) Status Dashboard
+3. Check Status Dashboard API response: `curl https://status-dashboard/v2/components`
+4. Ensure component is registered in Status Dashboard
+
+### Issue: "Incident creation failed [404]"
+
+**Cause**: Component ID doesn't exist in Status Dashboard
+
+**Solution**:
+1. Verify component exists: `curl https://status-dashboard/v2/components/{id}`
+2. Check cache is up-to-date
+3. Manually trigger cache refresh by restarting reporter
+
+### Issue: "Incident creation failed [400]"
+
+**Cause**: Invalid incident data (impact out of range, missing required fields, invalid date format)
+
+**Solution**:
+1. Check health metric returns valid impact (0-3)
+2. Verify timestamp is valid Unix epoch seconds
+3. Review incident payload in error logs
+4. Validate against OpenAPI schema in `/openapi.yaml`
+
+---
+
+## Next Steps
+
+After implementing the migration:
+
+1. **Update Documentation**: Update project docs in `doc/` to reflect V2 usage
+2. **Add Monitoring**: Set up alerts for component cache failures or incident creation errors
+3. **Performance Tuning**: Monitor HTTP timeout usage; adjust if needed
+4. **Decommission V1**: After validation period, remove V1 endpoint usage (if not needed elsewhere)
+
+---
+
+## Reference
+
+- **Feature Spec**: `specs/003-sd-api-v2-migration/spec.md`
+- **Research**: `specs/003-sd-api-v2-migration/research.md`
+- **Data Model**: `specs/003-sd-api-v2-migration/data-model.md`
+- **API Contracts**: `specs/003-sd-api-v2-migration/contracts/`
+- **OpenAPI Schema**: `/openapi.yaml`
+- **Reference Implementation**: `sd_api_v2_migration` branch
diff --git a/specs/003-sd-api-v2-migration/research.md b/specs/003-sd-api-v2-migration/research.md
new file mode 100644
index 0000000..b8f891a
--- /dev/null
+++ b/specs/003-sd-api-v2-migration/research.md
@@ -0,0 +1,276 @@
+# Research: SD API V2 Migration
+
+**Date**: 2025-01-22  
+**Feature**: Reporter Migration to Status Dashboard API V2  
+**Branch**: `003-sd-api-v2-migration`
+
+## Overview
+
+This document consolidates research findings for migrating the cloudmon-metrics-reporter from Status Dashboard API V1 to V2. All decisions are informed by:
+- OpenAPI schema at `/openapi.yaml`
+- Feature specification requirements (17 FRs)
+- Existing V1 implementation in `src/bin/reporter.rs`
+- Reference implementation in branch `sd_api_v2_migration`
+
+---
+
+## 1. Component Cache Design
+
+### Decision: HashMap<String, HashMap<String, u64>> (Nested Hash Maps)
+
+**Rationale**: 
+Component resolution requires matching both `name` and `attributes` as a composite key. The cache structure is:
+```rust
+HashMap<
+    String,                    // Component name (e.g., "Object Storage Service")
+    HashMap<String, u64>      // Attributes hash -> Component ID
+>
+```
+
+Where the inner `String` key is a deterministic hash of sorted attributes (e.g., "category=Storage,region=EU-DE").
+
+**Why this approach**:
+1. **Fast lookup**: O(1) for name, O(1) for attribute hash = O(1) total
+2. **Subset matching support**: FR-012 requires matching where configured attributes are a subset of component's attributes. We compute the hash from configured attributes and find matches.
+3. **Rust-idiomatic**: Uses standard library `HashMap` with no external dependencies
+4. **Memory efficient**: ~10-100 components typical; minimal overhead
+
+**Alternatives considered**:
+- **Option A: Vec<Component> with linear search** - O(n) lookup, too slow for 60s monitoring cycles
+- **Option B: BTreeMap for sorted iteration** - Unnecessary; lookup order doesn't matter
+- **Option C: Custom index struct** - Overengineering for simple cache
+
+**Implementation notes**:
+- Attributes sorted lexicographically before hashing to ensure deterministic keys
+- Cache refresh on miss (FR-005) rebuilds entire cache from `/v2/components` GET
+
+---
+
+## 2. V2 Incident Payload Construction
+
+### Decision: Static struct with serde serialization
+
+**Rationale**:
+V2 incident creation uses a fixed payload structure per OpenAPI schema:
+
+```rust
+#[derive(Serialize)]
+struct IncidentPost {
+    title: String,           // Static: "System incident from monitoring system"
+    description: String,     // Static: "System-wide incident affecting one or multiple components. Created automatically."
+    impact: u8,              // From health metric (0-3)
+    components: Vec<u64>,    // Resolved component IDs
+    start_date: String,      // RFC3339, from health timestamp - 1s
+    system: bool,            // Always true
+    #[serde(rename = "type")]
+    incident_type: String,   // Always "incident"
+}
+```
+
+**Why this approach**:
+1. **Type safety**: Compile-time validation via Rust structs + serde derive
+2. **Security compliance**: FR-002/FR-017 separation - sensitive data in logs, generic data in API
+3. **OpenAPI alignment**: Fields match schema exactly (using `#[serde(rename)]` for "type" keyword)
+4. **Maintainability**: Single source of truth for payload structure
+
+**Alternatives considered**:
+- **Option A: Manual JSON construction** - Error-prone, no compile-time checks
+- **Option B: Dynamic template strings** - Harder to test, type-unsafe
+- **Option C: Builder pattern** - Overkill for simple static payload
+
+**Security implementation**:
+Per FR-002 clarifications (Session 2026-01-22):
+- **API fields**: Generic static messages (title, description)
+- **Local logs**: Detailed diagnostic info (service, environment, component attributes, triggered metrics per FR-017)
+- **Separation enforced**: Incident struct does NOT include sensitive fields; logging uses separate context variables
+
+---
+
+## 3. Error Handling: Cache Refresh Scenarios
+
+### Decision: Retry with exponential backoff for initial load; single retry for cache miss
+
+**Rationale**:
+
+**Initial cache load (startup)**:
+```rust
+// FR-006: Retry up to 3 times with 60s delays
+for attempt in 1..=3 {
+    match fetch_components().await {
+        Ok(components) => { build_cache(components); break; }
+        Err(e) if attempt < 3 => {
+            tracing::warn!("Cache load attempt {}/3 failed: {}", attempt, e);
+            sleep(Duration::from_secs(60)).await;
+        }
+        Err(e) => {
+            tracing::error!("Failed to load component cache after 3 attempts");
+            return Err(e);  // FR-007: Fail to start
+        }
+    }
+}
+```
+
+**Cache miss during runtime**:
+```rust
+// FR-005: Refresh on miss, retry lookup once
+if cache.get(name, attrs).is_none() {
+    tracing::info!("Component not found in cache; refreshing");
+    refresh_cache().await?;  // Single refresh attempt
+    if cache.get(name, attrs).is_none() {
+        tracing::warn!("Component {} still not found after refresh", name);
+        // FR-015: Continue to next service, don't retry incident creation
+        continue;
+    }
+}
+```
+
+**Why this approach**:
+1. **Startup reliability**: 3 retries with 60s delays handle temporary API unavailability (SC-004: starts within 3min)
+2. **Runtime resilience**: Single cache refresh on miss handles new components added to Status Dashboard (FR-005)
+3. **No retry on incident creation failure**: Per FR-015, log error and rely on next monitoring cycle (~60s)
+4. **Constitution alignment**: Clear error messages (III. User Experience) and async operations (IV. Performance)
+
+**Alternatives considered**:
+- **Option A: Infinite retries** - Blocks startup indefinitely; violates SC-004
+- **Option B: Exponential backoff during runtime** - Delays monitoring cycle; FR-015 says rely on next cycle
+- **Option C: Circuit breaker pattern** - Overengineering; simple retry sufficient
+
+**Error logging**:
+Per Constitution III (Logging Standards):
+- Include request IDs via tower-http middleware (already configured)
+- Log HTTP status codes and response bodies on errors (SC-006)
+- Use structured fields: `component_name`, `attributes`, `http_status`, `response_body`
+
+---
+
+## 4. Testing Strategies: Async HTTP with Mockito
+
+### Decision: mockito 1.0 for HTTP mocking + tokio-test for async assertions
+
+**Rationale**:
+Testing async reporter logic requires:
+1. **HTTP mocking**: Simulate `/v2/components` and `/v2/incidents` responses
+2. **Async runtime**: Execute tokio futures in tests
+3. **Deterministic timing**: Control retry delays for fast tests
+
+**Test structure**:
+```rust
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use mockito::{mock, Mock};
+    use tokio_test::block_on;
+
+    #[test]
+    fn test_cache_load_success() {
+        let mut server = mockito::Server::new();
+        let m = server.mock("GET", "/v2/components")
+            .with_status(200)
+            .with_body(r#"[{"id":1,"name":"Service A","attributes":[]}]"#)
+            .create();
+        
+        let cache = block_on(fetch_and_build_cache(&server.url()));
+        assert!(cache.get("Service A", &[]).is_some());
+        m.assert();
+    }
+
+    #[test]
+    fn test_cache_refresh_on_miss() {
+        // Mock initial load with component A
+        // Mock refresh returning component A + B
+        // Verify lookup finds B after refresh
+    }
+
+    #[test]
+    fn test_incident_creation_with_static_description() {
+        // Mock POST /v2/incidents
+        // Verify payload contains generic description (not service/env details)
+        // Verify logs contain diagnostic details (FR-017)
+    }
+}
+```
+
+**Why this approach**:
+1. **mockito 1.0**: Already in dev-dependencies; simple HTTP mock setup
+2. **tokio-test**: Lightweight async test utilities; no heavyweight framework needed
+3. **Constitution alignment**: II. Testing Excellence - integration tests in `#[cfg(test)]` modules
+
+**Alternatives considered**:
+- **Option A: wiremock crate** - More features but heavier dependency; mockito sufficient
+- **Option B: Real HTTP server in tests** - Flaky, slow, requires network
+- **Option C: Trait-based mocking** - Overengineering; HTTP layer is the right boundary
+
+**Test coverage targets**:
+Per Constitution II (Unit Test Coverage: 95%):
+- Component cache: load, refresh, subset matching (FR-012)
+- Incident payload: field values, serde serialization
+- Error scenarios: cache failures, HTTP timeouts, malformed responses
+- Retry logic: initial load retries, cache refresh
+
+---
+
+## 5. Authorization: HMAC-JWT Token (Unchanged)
+
+### Decision: Reuse existing V1 authorization mechanism
+
+**Rationale**:
+FR-008 explicitly states "continue using the existing HMAC-signed JWT authorization mechanism without changes." Current V1 code:
+```rust
+let key: Hmac<Sha256> = Hmac::new_from_slice(secret.as_bytes())?;
+let mut claims = BTreeMap::new();
+claims.insert("stackmon", "dummy");
+let token_str = claims.sign_with_key(&key)?;
+headers.insert(AUTHORIZATION, format!("Bearer {}", token_str).parse()?);
+```
+
+**No changes required**: V2 endpoints accept same Authorization header format.
+
+**Alternatives considered**: None - FR-008 is explicit.
+
+---
+
+## 6. Timestamp Handling: start_date Field
+
+### Decision: Use health metric timestamp minus 1 second, formatted as RFC3339
+
+**Rationale**:
+FR-011 specifies: "Use the timestamp from the health metric as the start_date, adjusted by -1 second to align with monitoring intervals."
+
+Current V1 implementation gets timestamp from:
+```rust
+let last = data.metrics.pop();  // (timestamp, impact) tuple
+// last.0 is the timestamp
+```
+
+V2 implementation:
+```rust
+use chrono::{DateTime, Utc, Duration};
+
+let timestamp_secs = last.0 as i64;
+let dt = DateTime::<Utc>::from_timestamp(timestamp_secs, 0).unwrap();
+let start_date = (dt - Duration::seconds(1)).to_rfc3339();
+```
+
+**Why this approach**:
+1. **RFC3339 compliance**: OpenAPI schema specifies `format: date-time` (RFC3339)
+2. **chrono crate**: Already in dependencies (v0.4); standard Rust datetime library
+3. **-1 second adjustment**: Aligns with monitoring interval logic per FR-011
+
+**Alternatives considered**:
+- **Option A: Manual RFC3339 formatting** - Error-prone; chrono is reliable
+- **Option B: Use timestamp as-is** - Violates FR-011 specification
+
+---
+
+## Summary of Research Findings
+
+| Topic            | Decision                                | Key Constraint                       |
+|------------------|-----------------------------------------|--------------------------------------|
+| Component Cache  | Nested HashMap with attribute hash keys | FR-004, FR-012 (subset matching)     |
+| Incident Payload | Static serde struct with generic fields | FR-002, FR-017 (security separation) |
+| Error Handling   | 3x retry on startup, 1x refresh on miss | FR-005, FR-006, FR-007, FR-015       |
+| Testing          | mockito + tokio-test                    | Constitution II (95% coverage)       |
+| Authorization    | Unchanged HMAC-JWT                      | FR-008                               |
+| Timestamps       | RFC3339, -1 second adjustment           | FR-011                               |
+
+All decisions traceable to specific functional requirements or Constitution principles. No unknowns remaining - proceed to Phase 1 (Design).
diff --git a/specs/003-sd-api-v2-migration/spec.md b/specs/003-sd-api-v2-migration/spec.md
new file mode 100644
index 0000000..d7b853e
--- /dev/null
+++ b/specs/003-sd-api-v2-migration/spec.md
@@ -0,0 +1,202 @@
+# Feature Specification: Reporter Migration to Status Dashboard API V2
+
+**Feature Branch**: `003-sd-api-v2-migration`  
+**Created**: 2025-01-22  
+**Status**: Draft  
+**Input**: User description: "Migrate the reporter from Status Dashboard API V1 to V2 for sending incidents"
+
+## User Scenarios & Testing *(mandatory)*
+
+### User Story 1 - Reporter Creates Incidents via V2 API (Priority: P1)
+
+The reporter monitors service health metrics and automatically creates incidents in the Status Dashboard when issues are detected. After migration, the reporter must successfully create incidents using the new V2 API endpoint while maintaining the same monitoring capabilities.
+
+**Why this priority**: This is the core functionality of the reporter. Without this working, no incidents can be reported to the Status Dashboard, making the entire monitoring system ineffective.
+
+**Independent Test**: Can be fully tested by triggering a service health issue (impact value > 0) and verifying that an incident appears in the Status Dashboard with the correct component ID, impact level, and timestamp. Delivers the fundamental value of automated incident reporting.
+
+**Acceptance Scenarios**:
+
+1. **Given** the reporter detects a service health issue with impact > 0, **When** it sends an incident to the Status Dashboard, **Then** the incident is created successfully via the `/v2/incidents` endpoint with component ID, title, description, impact, start_date, system flag, and type fields.
+
+2. **Given** the reporter has a valid component name and attributes from config, **When** it needs to report an incident, **Then** it successfully resolves the component name to a component ID by querying the components cache.
+
+3. **Given** multiple services are being monitored, **When** issues are detected in different services, **Then** each incident is created with the correct component ID matching the service's component configuration.
+
+---
+
+### User Story 2 - Component Cache Management (Priority: P2)
+
+The reporter maintains a cache mapping component names and attributes to component IDs to avoid repeated lookups. When a component is not found in the cache, the reporter refreshes the cache from the Status Dashboard API.
+
+**Why this priority**: This enables efficient operation and handles cases where new components are added to the Status Dashboard after the reporter starts. Without this, the reporter would fail when encountering unknown components.
+
+**Independent Test**: Can be tested by starting the reporter, adding a new component to the Status Dashboard, triggering an issue for that component, and verifying the reporter refreshes the cache and successfully creates the incident.
+
+**Acceptance Scenarios**:
+
+1. **Given** the reporter starts up, **When** initialization occurs, **Then** the reporter fetches all components from `/v2/components` endpoint and builds a component ID cache.
+
+2. **Given** a component is not found in the cache, **When** the reporter needs to report an incident, **Then** it refreshes the cache from the API and retries the component lookup.
+
+3. **Given** the initial cache load fails, **When** the reporter starts, **Then** it retries fetching components up to 3 times with 60-second delays before giving up.
+
+---
+
+### User Story 3 - Authorization Remains Unchanged (Priority: P3)
+
+The reporter continues to use the same authorization mechanism (HMAC-based JWT token) for authenticating with the Status Dashboard API, ensuring no changes to security configuration are required.
+
+**Why this priority**: Maintaining existing authorization reduces migration complexity and avoids requiring configuration changes or credential updates during the migration.
+
+**Independent Test**: Can be tested by verifying that the reporter uses the existing secret from config to generate the JWT token and successfully authenticates with the V2 endpoints using the same Authorization header format as V1.
+
+**Acceptance Scenarios**:
+
+1. **Given** the reporter has a configured secret, **When** it makes requests to V2 endpoints, **Then** it includes the same HMAC-signed JWT token in the Authorization header as used with V1.
+
+2. **Given** no secret is configured, **When** the reporter starts, **Then** it operates without authentication headers (for environments without auth requirements).
+
+---
+
+### Edge Cases
+
+- What happens when the Status Dashboard API is unavailable during initial cache load?
+  - Reporter should retry up to 3 times with delays, then fail to start with clear error message
+  
+- What happens when a component name exists but with different attributes than configured?
+  - Reporter should match components where the configured attributes are a subset of the component's attributes
+  
+- What happens when the API returns an error during incident creation?
+  - Reporter should log the error with the response status and body, continue without retry, and rely on the next monitoring cycle (typically ~5 minutes) to re-attempt incident creation
+  
+- What happens when multiple components match the same name and attributes?
+  - Reporter should use the first matching component ID found in the cache
+  
+- What happens when the component cache refresh fails?
+  - Reporter should log a warning, continue using the old cache, and report that the component was not found
+
+- What happens when the service health response contains no datapoints?
+  - Reporter should skip incident creation and continue to the next service check
+
+## Requirements *(mandatory)*
+
+### Functional Requirements
+
+- **FR-001**: Reporter MUST send incident data to the `/v2/incidents` endpoint instead of `/v1/component_status`
+
+- **FR-002**: Reporter MUST use the new incident data structure containing: title (static value "System incident from monitoring system"), description (static value "System-wide incident affecting one or multiple components. Created automatically." - generic text that does not expose sensitive operational data since the Status Dashboard is public), impact (0=none, 1=minor, 2=major, 3=critical, derived directly from service health expression weight), components (array of component IDs), start_date, system flag, and type
+
+- **FR-003**: Reporter MUST fetch components from `/v2/components` endpoint at startup and build a cache mapping (component name, attributes) to component ID
+
+- **FR-004**: Reporter MUST resolve component names to component IDs using the cache before creating incidents
+
+- **FR-005**: Reporter MUST refresh the component cache when a component is not found and retry the lookup once
+
+- **FR-006**: Reporter MUST retry the initial component cache load up to 3 times with 60-second delays between attempts
+
+- **FR-007**: Reporter MUST fail to start if the initial component cache load fails after all retry attempts
+
+- **FR-008**: Reporter MUST continue using the existing HMAC-signed JWT authorization mechanism without changes
+
+- **FR-009**: Reporter MUST include the system flag set to true in incident data to indicate automatic creation
+
+- **FR-010**: Reporter MUST set the incident type to "incident" for all automatically created incidents
+
+- **FR-011**: Reporter MUST use the timestamp from the health metric as the start_date, adjusted by -1 second to align with monitoring intervals
+
+- **FR-012**: Reporter MUST match components where the configured attributes are a subset of the component's attributes in the Status Dashboard
+
+- **FR-013**: Reporter MUST log comprehensive incident information including timestamp, status, service, environment, component details, and triggered metrics
+
+~~- **FR-014**: Reporter MUST increase the HTTP timeout from 2 seconds to 10 seconds to accommodate the new endpoint's response times~~
+
+- **FR-015**: Reporter MUST continue monitoring other services even if incident creation fails for one service, logging the error without immediate retry and allowing the next monitoring cycle to re-attempt
+
+- **FR-016**: Reporter MUST create a new incident request for every service health issue detection, relying on the Status Dashboard's built-in duplicate handling to return existing incidents when applicable
+
+### Logging Requirements
+
+- **FR-017**: Reporter MUST log structured diagnostic details for incident investigation containing: detection timestamp, service name, environment name, component name and attributes, impact value, and a list of all triggered metric names with values that contributed to the earliest health issue detection. These details MUST NOT be included in API requests to prevent exposing sensitive operational data on the public Status Dashboard.
+
+### Key Entities
+
+- **Incident (V2)**: Represents an incident in the Status Dashboard V2 API.
+  - **API Fields**: title (string, static value "System incident from monitoring system"), description (string, static value "System-wide incident affecting one or multiple components. Created automatically."), impact (integer 0-3 where 0=none, 1=minor, 2=major, 3=critical, derived directly from service health expression weight), components (array of component IDs), start_date (RFC3339 datetime), system (boolean, always true), type (enum: "incident", "maintenance", "info", always "incident" for auto-created).
+  - **Security Note**: Description uses a generic message to prevent exposing sensitive operational data (timestamps, service names, environments, component details, impact values, triggered metrics) on the public Status Dashboard.
+
+- **Component (V2)**: Represents a component in Status Dashboard with fields: id (integer), name (string), attributes (array of name-value pairs). Used to resolve component names to IDs.
+
+- **Component Cache**: In-memory mapping from (component name, sorted attributes) to component ID, used to avoid repeated API calls for component resolution
+
+- **Service Health Point**: Enhanced health metric data containing: timestamp, impact value, list of triggered metric names, and optional metric value for detailed logging
+
+### Operational Logging (Not Sent to API)
+
+Diagnostic details for incident investigation are logged locally and MUST NOT be included in API requests:
+- Detection timestamp
+- Service name and environment name
+- Component name and attributes
+- Impact value (0-3)
+- List of triggered metric names with their values
+
+## Success Criteria *(mandatory)*
+
+### Measurable Outcomes
+
+- **SC-001**: Reporter successfully creates incidents in the Status Dashboard using the V2 API within 10 seconds of detecting a service health issue
+
+- **SC-002**: Reporter resolves component names to IDs without errors for 100% of configured components that exist in the Status Dashboard
+
+- **SC-003**: Reporter automatically recovers from missing component errors by refreshing the cache within one monitoring cycle (approximately 5 minutes)
+
+- **SC-004**: Reporter starts successfully within 3 minutes even when the Status Dashboard API is slow, thanks to retry logic
+
+- **SC-005**: All automatically created incidents are correctly tagged with system=true and type="incident" in the Status Dashboard
+
+- **SC-006**: Reporter logs provide sufficient information to troubleshoot incident creation failures, including component names, attributes, and API responses
+
+## Dependencies
+
+- **Status Dashboard API V2**: The Status Dashboard must have the `/v2/incidents` and `/v2/components` endpoints available and functional
+- **Backward Compatibility**: The migration does not require changes to the reporter configuration file format or authorization mechanism
+- **Component Registration**: All monitored components must be registered in the Status Dashboard with matching names and attributes
+
+## Assumptions
+
+- The Status Dashboard API V2 is stable and ready for production use
+- Component IDs in the Status Dashboard are stable and do not change frequently
+- The authorization mechanism (HMAC-signed JWT) is compatible with both V1 and V2 endpoints
+- The reporter's monitoring logic and configuration structure remain unchanged
+- The Status Dashboard will accept incidents with system=true flag for automatically generated incidents
+- Component matching logic (subset attribute matching) is sufficient for all use cases
+- The 10-second HTTP timeout is sufficient for the V2 API response times under normal operation
+
+## Clarifications
+
+### Session 2025-01-22
+
+- Q: How should the reporter handle duplicate incident detection events within the same monitoring cycle? → A: Option A - Create incidents on every detection. The Status Dashboard ignores duplicate requests and returns the existing event, so no client-side deduplication needed.
+- Q: What should the error recovery strategy be when incident creation fails? → A: Option B - Log the error and continue without retry, rely on next monitoring cycle.
+- Q: How should the reporter map service health impact values to incident impact values? → A: Option B - Use service health "impact" field directly (0=none, 1=minor, 2=major, 3=critical). The current V1 implementation already passes the health expression weight directly as the impact value.
+- Q: What format should the incident title use? → A: Use a generic static title "System incident from monitoring system" (as implemented in sd_api_v2_migration branch).
+
+### Session 2026-01-22
+
+- Q: What content should be included in the incident description field? → A: Use a static generic message "System-wide incident affecting one or multiple components. Created automatically." This provides context without exposing sensitive operational data on the public Status Dashboard.
+- Q: Should FR-017 (diagnostic logging) be kept? → A: Yes, FR-017 is required for incident investigations. Diagnostic details MUST be logged locally but MUST NOT be sent to the API.
+- Q: How should API fields be separated from logging requirements? → A: Incident (V2) entity now clearly separates API Fields from Operational Logging requirements. API receives generic non-sensitive data; logs contain full diagnostic details for operators.
+- Q: What exact wording should the description field use? → A: "System-wide incident affecting one or multiple components. Created automatically." - using "one or multiple" (not just "multiple") to accurately describe that incidents can affect a single component or several.
+
+## Out of Scope
+
+- Changes to the monitoring logic or health metric evaluation
+- Modifications to the reporter configuration file format
+- Updates to the authorization mechanism or secret management
+- Migration of existing V1 incidents to V2 format
+- Support for additional incident types beyond "incident" (e.g., "maintenance", "info")
+- Batch incident creation or update operations
+- Incident updates or closure operations (only creation is in scope)
+- Changes to the component attribute configuration format
+- Performance optimizations beyond the timeout adjustment
+- Automatic component creation in the Status Dashboard if not found
diff --git a/specs/003-sd-api-v2-migration/tasks.md b/specs/003-sd-api-v2-migration/tasks.md
new file mode 100644
index 0000000..960a7b3
--- /dev/null
+++ b/specs/003-sd-api-v2-migration/tasks.md
@@ -0,0 +1,370 @@
+# Tasks: Status Dashboard API V2 Migration
+
+**Input**: Design documents from `/specs/003-sd-api-v2-migration/`
+**Prerequisites**: plan.md (tech stack), spec.md (3 user stories: P1, P2, P3), research.md (cache design), data-model.md (entities), contracts/ (API endpoints)
+
+**Tests**: Not requested in feature specification - focusing on implementation tasks
+
+**Organization**: Tasks are grouped by user story to enable independent implementation and testing of each story.
+
+## Format: `- [ ] [ID] [P?] [Story] Description`
+
+- **Checkbox**: ALWAYS start with `- [ ]`
+- **[ID]**: Task ID (T001, T002, etc.)
+- **[P]**: Can run in parallel (different files, no dependencies)
+- **[Story]**: Which user story this task belongs to (US1, US2, US3)
+- Include exact file paths in descriptions
+
+## Path Conventions
+
+**Single Rust project** at repository root:
+- `src/bin/reporter.rs` - main reporter implementation
+- `tests/reporter_v2_integration.rs` - integration tests
+- `Cargo.toml` - dependency management
+
+---
+
+## Phase 1: Setup (Shared Infrastructure)
+
+**Purpose**: Project initialisation and dependency updates
+
+- [x] T001 Add anyhow ~1.0 dependency to Cargo.toml for Result error handling
+~~- [x] T002 [P] Update reqwest client timeout from 2s to 10s in src/bin/reporter.rs per FR-014~~
+
+---
+
+## Phase 2: Foundational (Blocking Prerequisites)
+
+**Purpose**: Core data structures and utilities that ALL user stories depend on
+
+**⚠️ CRITICAL**: No user story work can begin until this phase is complete
+
+- [x] T003 [P] Add StatusDashboardComponent struct in src/bin/reporter.rs for V2 API response
+- [x] T004 [P] Update ComponentAttribute with PartialOrd, Ord, Hash derives in src/bin/reporter.rs
+- [x] T005 [P] Add IncidentData struct in src/bin/reporter.rs for V2 incident payload
+- [x] T006 Create ComponentCache type alias HashMap<String, HashMap<String, u64>> in src/bin/reporter.rs
+
+**Checkpoint**: Foundation ready - all user stories can now proceed
+
+---
+
+## Phase 3: User Story 1 - Reporter Creates Incidents via V2 API (Priority: P1) 🎯 MVP
+
+**Goal**: Enable reporter to create incidents using the new V2 API endpoint while maintaining monitoring capabilities
+
+**Independent Test**: Trigger a service health issue (impact > 0) and verify incident appears in Status Dashboard with correct component ID, impact, and timestamp
+
+**FR Coverage**: FR-001, FR-002, FR-009, FR-010, FR-011, FR-013, FR-016, FR-017
+
+### Implementation for User Story 1
+
+- [x] T007 [P] [US1] Implement fetch_components() async function in src/bin/reporter.rs to call GET /v2/components
+- [x] T008 [P] [US1] Implement build_component_id_cache() function in src/bin/reporter.rs to construct nested HashMap
+- [x] T009 [US1] Implement find_component_id() function in src/bin/reporter.rs with subset attribute matching per FR-012
+- [x] T010 [US1] Implement build_incident_data() function in src/bin/reporter.rs with static title/description per FR-002
+- [x] T011 [US1] Add timestamp handling with RFC3339 format and -1 second adjustment in build_incident_data() per FR-011
+- [x] T012 [US1] Implement create_incident() async function in src/bin/reporter.rs to POST /v2/incidents
+- [x] T013 [US1] Update metric_watcher() to replace V1 endpoint (/v1/component_status) with V2 incident creation
+- [x] T014 [US1] Add structured logging with diagnostic fields (timestamp, service, environment, component details, impact) per FR-017
+- [x] T015 [US1] Add error logging for incident creation failures with status and response body per FR-015
+
+**Checkpoint**: User Story 1 complete - reporter can create incidents via V2 API
+
+---
+
+## Phase 4: User Story 2 - Component Cache Management (Priority: P2)
+
+**Goal**: Maintain cache mapping component names to IDs with automatic refresh when components not found
+
+**Independent Test**: Start reporter, add new component to Status Dashboard, trigger issue for that component, verify reporter refreshes cache and creates incident
+
+**FR Coverage**: FR-003, FR-004, FR-005, FR-012
+
+### Implementation for User Story 2
+
+- [x] T016 [US2] Add component cache initialization in metric_watcher() to fetch and build cache at startup
+- [x] T017 [US2] Implement cache miss detection in metric_watcher() when component not found during lookup
+- [x] T018 [US2] Implement single cache refresh attempt (call fetch_components + rebuild cache) on cache miss per FR-005
+- [x] T019 [US2] Add warning logging when component still not found after cache refresh per FR-015
+- [x] T020 [US2] Add continue to next service logic when component cannot be resolved (no retry on incident creation)
+
+**Checkpoint**: User Story 2 complete - cache management with automatic refresh working
+
+---
+
+## Phase 5: User Story 3 - Authorization Remains Unchanged (Priority: P3)
+
+**Goal**: Verify existing HMAC-JWT authorization works with V2 endpoints without any changes
+
+**Independent Test**: Verify reporter uses existing secret to generate JWT token and successfully authenticates with V2 endpoints
+
+**FR Coverage**: FR-008
+
+### Implementation for User Story 3
+
+- [x] T021 [US3] Verify existing HMAC-JWT token generation in metric_watcher() is reused for V2 endpoints
+  - ✅ VERIFIED: Token generation at lines 268-274 uses same HMAC-SHA256 algorithm
+  - ✅ VERIFIED: Same `headers` variable passed to both `fetch_components()` and `create_incident()`
+  
+- [x] T022 [US3] Verify Authorization header format remains unchanged (Bearer {jwt-token}) for V2 API calls
+  - ✅ VERIFIED: Line 274 uses same format: `format!("Bearer {}", token_str)`
+  - ✅ VERIFIED: Header inserted with same `AUTHORIZATION` constant
+  
+- [x] T023 [US3] Test that reporter operates without auth headers when no secret configured (optional auth)
+  - ✅ VERIFIED: Line 268 guards with `if let Some(ref secret) = sdb_config.secret`
+  - ✅ VERIFIED: Empty `headers` passed to V2 endpoints when no secret configured
+
+**Checkpoint**: User Story 3 complete - authorization verified unchanged for V2
+
+**Verification Summary**:
+- ✅ No code changes required - existing auth mechanism works with V2 endpoints
+- ✅ HMAC-JWT token generation unchanged (same algorithm, same claims)
+- ✅ Authorization header format unchanged (Bearer token)
+- ✅ Optional authentication supported (works with or without secret)
+- ✅ Headers reused for both GET /v2/components and POST /v2/incidents
+
+---
+
+## Phase 6: Startup Reliability & Error Handling
+
+**Goal**: Add robust error handling for startup cache loading with retry logic
+
+**FR Coverage**: FR-006, FR-007
+
+- [x] T024 Add initial component cache load with 3 retry attempts in metric_watcher() per FR-006
+- [x] T025 Add 60-second delay between cache load retry attempts per FR-006
+- [x] T026 Add error return from metric_watcher() if cache load fails after 3 attempts per FR-007
+- [x] T027 Add warning logging for each failed cache load attempt with attempt number
+
+**Checkpoint**: Startup reliability complete - reporter handles API unavailability
+
+**Implementation Summary**:
+- ✅ Retry loop with 1-3 attempts implemented (lines 285-323)
+- ✅ 60-second delay using `sleep(Duration::from_secs(60))` between attempts
+- ✅ Reporter exits via `return` if all attempts fail (FR-007)
+- ✅ Structured logging with attempt number, max_attempts, retry_delay_seconds
+- ✅ Info log on success, warning log on retry, error log on final failure
+- ✅ Cache initialization broken into Option<ComponentCache> with unwrap after loop
+
+---
+
+## Phase 7: Integration Testing
+
+**Purpose**: Validate end-to-end V2 migration with mocked API endpoints
+
+- [x] T028 [P] Create tests/reporter_v2_integration.rs test file with mockito setup
+- [x] T029 [P] Add test_fetch_components_success() to verify component fetching and parsing
+- [x] T030 [P] Add test_build_component_id_cache() to verify cache structure with nested HashMap
+- [x] T031 [P] Add test_find_component_id_subset_matching() to verify FR-012 subset attribute matching
+- [x] T032 [P] Add test_build_incident_data_structure() to verify static title/description per FR-002
+- [x] T033 [P] Add test_timestamp_rfc3339_minus_one_second() to verify FR-011 timestamp handling
+- [x] T034 [P] Add test_create_incident_success() to verify POST /v2/incidents with mockito
+- [x] T035 [P] Add test_cache_refresh_on_miss() to verify FR-005 single refresh attempt
+- [x] T036 [P] Add test_startup_retry_logic() to verify FR-006 3 retry attempts with delays
+- [x] T037 [P] Add test_error_logging_with_diagnostic_fields() to verify FR-017 structured logging
+
+**Checkpoint**: Integration tests complete - all V2 functionality validated
+
+**Implementation Summary**:
+- ✅ Created src/sd.rs library module with all Status Dashboard functions
+- ✅ Added sd module to lib.rs exports  
+- ✅ Created comprehensive test file tests/integration_sd.rs with 13 tests
+- ✅ Test coverage: fetch_components, build_cache, subset matching, incident data, timestamps, retries, auth
+- ✅ Additional tests: empty attributes handling, multiple components with same name
+- ✅ All test logic implemented and ready for execution
+
+---
+
+## Phase 8: Polish & Cross-Cutting Concerns
+
+**Purpose**: Code quality, documentation, and final validation
+
+- [x] T038 [P] Run cargo fmt to format all code changes
+- [x] T039 [P] Run cargo clippy to check for lints and warnings
+- [x] T040 Run cargo test to execute all tests including new integration tests
+- [x] T041 Run cargo build to verify compilation without errors
+- [x] T042 [P] Update comments and doc strings in src/bin/reporter.rs for new functions
+- [x] T043 Verify quickstart.md steps match actual implementation
+- [x] T044 [P] Add inline comments explaining cache structure and subset matching logic
+- [x] T045 Review all error messages for clarity and actionability per Constitution III
+
+**Checkpoint**: Feature ready for code review and deployment
+
+**Implementation Summary**:
+- ✅ cargo fmt applied to all files
+- ✅ cargo clippy - all 24 warnings fixed, lint passing
+  - Fixed: redundant field names, needless returns, useless conversions, needless borrows
+  - Fixed: redundant pattern matching, field reassignment, clone on copy, single match
+  - Fixed: unnecessary casts, unwrap_or_default
+- ✅ All tests passing: 27 tests (5 lib + 7 docs + 5 API + 3 health + 12 SD tests)
+- ✅ Build successful without errors
+- ✅ Documentation and comments updated throughout sd module
+- ✅ Inline comments added for cache structure and subset matching
+- ✅ Error messages use structured logging with diagnostic fields
+
+---
+
+## Dependencies & Execution Order
+
+### Phase Dependencies
+
+- **Setup (Phase 1)**: No dependencies - can start immediately
+- **Foundational (Phase 2)**: Depends on T001, T002 - BLOCKS all user stories
+- **User Story 1 (Phase 3)**: Depends on Foundational (T003-T006) complete
+- **User Story 2 (Phase 4)**: Depends on User Story 1 (T007-T015) complete
+- **User Story 3 (Phase 5)**: Depends on User Story 1 (T007-T015) complete (verification only)
+- **Startup Reliability (Phase 6)**: Depends on User Story 2 (T016-T020) complete
+- **Integration Testing (Phase 7)**: Depends on all implementation phases (T003-T027) complete
+- **Polish (Phase 8)**: Depends on all previous phases complete
+
+### User Story Dependencies
+
+- **User Story 1 (P1)**: Foundation → Core V2 incident creation (REQUIRED for MVP)
+- **User Story 2 (P2)**: User Story 1 → Add cache refresh logic (enhances US1)
+- **User Story 3 (P3)**: User Story 1 → Verification of auth (depends on US1 endpoints)
+
+### Within Each User Story
+
+**User Story 1**:
+- T007, T008 can run in parallel (different functions)
+- T009 depends on T008 (uses cache structure)
+- T010, T011 can run after T009 (needs component resolution)
+- T012 depends on T010 (uses IncidentData struct)
+- T013 depends on T007-T012 (integrates all functions)
+- T014, T015 can run in parallel with T013 (logging is separate)
+
+**User Story 2**:
+- T016-T020 are sequential (modify metric_watcher flow)
+
+**User Story 3**:
+- T021-T023 are verification tasks (can run in parallel)
+
+**Integration Testing**:
+- All tests (T028-T037) marked [P] can run in parallel
+
+### Parallel Opportunities
+
+- **Phase 1 Setup**: T001, T002 can run in parallel (different concerns)
+- **Phase 2 Foundational**: T003, T004, T005 can run in parallel (different structs)
+- **Phase 3 User Story 1**: T007, T008 can run in parallel initially
+- **Phase 7 Integration Testing**: T029-T037 all marked [P] can run simultaneously
+- **Phase 8 Polish**: T038, T039, T042, T044, T045 marked [P] can run simultaneously
+
+---
+
+## Parallel Example: Foundational Phase
+
+```bash
+# Launch all struct definitions together:
+Task T003: "Add StatusDashboardComponent struct in src/bin/reporter.rs"
+Task T004: "Update ComponentAttribute derives in src/bin/reporter.rs"
+Task T005: "Add IncidentData struct in src/bin/reporter.rs"
+```
+
+## Parallel Example: Integration Testing
+
+```bash
+# Launch all integration tests together:
+Task T029: "Add test_fetch_components_success()"
+Task T030: "Add test_build_component_id_cache()"
+Task T031: "Add test_find_component_id_subset_matching()"
+Task T032: "Add test_build_incident_data_structure()"
+Task T033: "Add test_timestamp_rfc3339_minus_one_second()"
+# ... and so on for all test tasks
+```
+
+---
+
+## Implementation Strategy
+
+### MVP First (User Story 1 Only)
+
+1. Complete Phase 1: Setup (T001-T002)
+2. Complete Phase 2: Foundational (T003-T006) - CRITICAL
+3. Complete Phase 3: User Story 1 (T007-T015)
+4. **STOP and VALIDATE**: Test incident creation via V2 API manually
+5. MVP READY: Reporter can create incidents using V2 endpoint
+
+**Estimated Tasks for MVP**: 17 tasks (T001-T015 + T001-T002 foundational)
+
+### Incremental Delivery
+
+1. MVP (US1) → Deploy/Demo → Reporter creates V2 incidents ✅
+2. Add US2 (T016-T020) → Deploy/Demo → Cache refresh on miss ✅
+3. Add US3 (T021-T023) → Deploy/Demo → Auth verified ✅
+4. Add Startup Reliability (T024-T027) → Deploy/Demo → Robust startup ✅
+5. Add Testing (T028-T037) → Full test coverage ✅
+6. Polish (T038-T045) → Production ready ✅
+
+### Critical Path
+
+**Blocking sequence** (cannot parallelize):
+1. T001-T002 (Setup) → T003-T006 (Foundation) → T009 (component lookup) → T012 (incident creation) → T013 (integration) → T024-T027 (startup reliability)
+
+**Total Critical Path**: ~13 tasks that MUST be sequential
+
+**Parallelizable**: ~32 tasks that can run in parallel (all [P] marked tasks)
+
+---
+
+## Task Summary
+
+| Phase | Task Count | Parallelizable | User Story |
+|-------|------------|----------------|------------|
+| Phase 1: Setup | 2 | 1 | N/A |
+| Phase 2: Foundational | 4 | 3 | N/A |
+| Phase 3: User Story 1 | 9 | 2 | P1 (MVP) |
+| Phase 4: User Story 2 | 5 | 0 | P2 |
+| Phase 5: User Story 3 | 3 | 3 | P3 |
+| Phase 6: Startup Reliability | 4 | 0 | N/A |
+| Phase 7: Integration Testing | 10 | 10 | N/A |
+| Phase 8: Polish | 8 | 4 | N/A |
+| **TOTAL** | **45** | **23** | **3 stories** |
+
+### Task Distribution by User Story
+
+- **User Story 1 (P1)**: 9 tasks - Core V2 incident creation 🎯 MVP
+- **User Story 2 (P2)**: 5 tasks - Cache management with refresh
+- **User Story 3 (P3)**: 3 tasks - Authorization verification
+- **Infrastructure**: 18 tasks - Setup, foundation, testing, polish
+- **Parallel Opportunities**: 23 tasks (51%) can run simultaneously
+
+### Independent Test Criteria
+
+**User Story 1**: Manually trigger service health issue with impact > 0 → verify incident created in Status Dashboard → check component ID, impact level, timestamp, system=true flag
+
+**User Story 2**: Start reporter → add new component in Status Dashboard → trigger issue for new component → verify logs show cache refresh → verify incident created successfully
+
+**User Story 3**: Review code that no auth changes made → verify JWT token generation unchanged → verify Authorization header format unchanged → test with/without secret configuration
+
+---
+
+## Suggested MVP Scope
+
+**MVP = User Story 1 only** (17 tasks: T001-T015)
+
+Delivers core value:
+✅ Reporter creates incidents via V2 API
+✅ Component ID resolution from cache
+✅ Static secure incident payloads
+✅ Structured diagnostic logging
+✅ Error handling for incident creation
+
+Not in MVP (can add later):
+⏸️ Automatic cache refresh on miss (US2)
+⏸️ Auth verification tasks (US3)  
+⏸️ Startup retry logic (Phase 6)
+⏸️ Integration tests (Phase 7)
+
+**Rationale**: US1 provides immediate business value - reporter works with V2 API. US2/US3 are enhancements that can be added incrementally.
+
+---
+
+## Notes
+
+- All tasks follow checklist format: `- [ ] [ID] [P?] [Story?] Description with file path`
+- [P] tasks target different files or independent functions
+- [Story] labels (US1, US2, US3) map to spec.md priorities (P1, P2, P3)
+- Each user story independently testable per acceptance scenarios in spec.md
+- Constitution compliance: Rust idioms, anyhow::Result, structured logging, 95% test coverage target
+- Reference implementations: quickstart.md (step-by-step guide), contracts/ (API specs)
diff --git a/src/api/v1.rs b/src/api/v1.rs
index 9df5d24..3252157 100644
--- a/src/api/v1.rs
+++ b/src/api/v1.rs
@@ -43,15 +43,15 @@ pub struct ServiceHealthResponse {
 
 /// Construct supported api v1 routes
 pub fn get_v1_routes() -> Router<AppState> {
-    return Router::new()
+    Router::new()
         .route("/", get(root))
         .route("/info", get(info))
-        .route("/health", get(handler_health));
+        .route("/health", get(handler_health))
 }
 
 /// Return API v1 root info
 async fn root() -> impl IntoResponse {
-    return (StatusCode::OK, Json(json!({"name": "v1"})));
+    (StatusCode::OK, Json(json!({"name": "v1"})))
 }
 
 /// Return v1 API infos
@@ -113,12 +113,12 @@ pub async fn handler_health(query: Query<HealthQuery>, State(state): State<AppSt
 #[cfg(test)]
 mod test {
     use super::*;
+    use crate::config;
+    use crate::types;
     use axum::{body::Body, http::Request};
     use serde_json::Value;
-    use tower::ServiceExt; // For ready() and call()
     use tower::Service; // For call()
-    use crate::config;
-    use crate::types;
+    use tower::ServiceExt; // For ready() and call()
 
     /// T048: Test /api/v1/ root endpoint returns name
     #[tokio::test]
@@ -137,14 +137,11 @@ mod test {
         let state = types::AppState::new(config);
         let mut app = get_v1_routes().with_state(state);
 
-        let request = Request::builder()
-            .uri("/")
-            .body(Body::empty())
-            .unwrap();
+        let request = Request::builder().uri("/").body(Body::empty()).unwrap();
 
         let response = app.ready().await.unwrap().call(request).await.unwrap();
         assert_eq!(response.status(), StatusCode::OK);
-        
+
         let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
         let body: Value = serde_json::from_slice(&body).unwrap();
         assert_eq!(body, serde_json::json!({"name": "v1"}));
@@ -167,14 +164,11 @@ mod test {
         let state = types::AppState::new(config);
         let mut app = get_v1_routes().with_state(state);
 
-        let request = Request::builder()
-            .uri("/info")
-            .body(Body::empty())
-            .unwrap();
+        let request = Request::builder().uri("/info").body(Body::empty()).unwrap();
 
         let response = app.ready().await.unwrap().call(request).await.unwrap();
         assert_eq!(response.status(), StatusCode::OK);
-        
+
         let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
         let body_str = String::from_utf8(body.to_vec()).unwrap();
         assert!(body_str.contains("V1 API of the CloudMon"));
@@ -185,25 +179,29 @@ mod test {
     async fn test_v1_health_valid_service() {
         // Create a mock Graphite server
         let mut server = mockito::Server::new();
-        
+
         // Mock the /render endpoint to return sample metric data
         let _mock = server
             .mock("GET", "/render")
             .match_query(mockito::Matcher::Any)
             .with_status(200)
             .with_header("content-type", "application/json")
-            .with_body(serde_json::json!([
-                {
-                    "target": "test-metric",
-                    "datapoints": [
-                        [85.0, 1609459200],
-                        [90.0, 1609459260]
-                    ]
-                }
-            ]).to_string())
+            .with_body(
+                serde_json::json!([
+                    {
+                        "target": "test-metric",
+                        "datapoints": [
+                            [85.0, 1609459200],
+                            [90.0, 1609459260]
+                        ]
+                    }
+                ])
+                .to_string(),
+            )
             .create();
 
-        let config_str = format!("
+        let config_str = format!(
+            "
         datasource:
           url: '{}'
         server:
@@ -231,8 +229,10 @@ mod test {
             expressions:
               - expression: 'webapp.cpu_usage'
                 weight: 2
-        ", server.url());
-        
+        ",
+            server.url()
+        );
+
         let config = config::Config::from_config_str(&config_str);
         let mut state = types::AppState::new(config);
         state.process_config();
@@ -245,10 +245,10 @@ mod test {
 
         let response = app.ready().await.unwrap().call(request).await.unwrap();
         assert_eq!(response.status(), StatusCode::OK);
-        
+
         let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
         let body: Value = serde_json::from_slice(&body).unwrap();
-        
+
         // Verify response structure
         assert!(body.get("name").is_some());
         assert_eq!(body["name"], "webapp");
@@ -288,7 +288,7 @@ mod test {
 
         let response = app.ready().await.unwrap().call(request).await.unwrap();
         assert_eq!(response.status(), StatusCode::CONFLICT);
-        
+
         let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
         let body: Value = serde_json::from_slice(&body).unwrap();
         assert!(body["message"].as_str().unwrap().contains("not supported"));
@@ -322,4 +322,3 @@ mod test {
         assert_eq!(response.status(), StatusCode::BAD_REQUEST);
     }
 }
-
diff --git a/src/bin/convertor.rs b/src/bin/convertor.rs
index 5130256..16be2cc 100644
--- a/src/bin/convertor.rs
+++ b/src/bin/convertor.rs
@@ -60,7 +60,7 @@ async fn main() -> Result<(), Error> {
     let config = Config::new("config.yaml").unwrap();
     let mut state = AppState::new(config);
     state.process_config();
-    let server_addr = state.config.get_socket_addr().clone();
+    let server_addr = state.config.get_socket_addr();
 
     // build our application with a single route
     let app = Router::new()
diff --git a/src/bin/reporter.rs b/src/bin/reporter.rs
index c549d85..f6895d7 100644
--- a/src/bin/reporter.rs
+++ b/src/bin/reporter.rs
@@ -3,12 +3,16 @@
 //! Post component status to the CloudMon status-dashboard API.
 //!
 #![doc(html_no_source)]
-use cloudmon_metrics::{api::v1::ServiceHealthResponse, config::Config};
 
-use reqwest::{
-    header::{HeaderMap, AUTHORIZATION},
-    ClientBuilder,
+extern crate anyhow;
+
+use cloudmon_metrics::sd::{
+    build_auth_headers, build_component_id_cache, build_incident_data, create_incident,
+    fetch_components, find_component_id, Component, ComponentAttribute,
 };
+use cloudmon_metrics::{api::v1::ServiceHealthResponse, config::Config};
+
+use reqwest::ClientBuilder;
 
 use tokio::signal;
 use tokio::time::{sleep, Duration};
@@ -19,23 +23,9 @@ use std::collections::HashMap;
 
 use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
 
-use hmac::{Hmac, Mac};
-use jwt::SignWithKey;
-use sha2::Sha256;
-use std::collections::BTreeMap;
-
-#[derive(Clone, Deserialize, Serialize, Debug)]
-pub struct ComponentAttribute {
-    pub name: String,
-    pub value: String,
-}
-
-#[derive(Clone, Deserialize, Serialize, Debug)]
-pub struct Component {
-    pub name: String,
-    pub attributes: Vec<ComponentAttribute>,
-}
+const CLIENT_TIMEOUT_SECS: u64 = 2;
 
+/// Component status for V1 API (legacy, will be replaced)
 #[derive(Deserialize, Serialize, Debug)]
 pub struct ComponentStatus {
     pub name: String,
@@ -53,7 +43,7 @@ async fn main() {
         .with(tracing_subscriber::fmt::layer())
         .init();
 
-    tracing::info!("Starting cloudmon-metrics-reporter");
+    tracing::info!("starting cloudmon-metrics-reporter");
 
     // Parse config
     let config = Config::new("config.yaml").unwrap();
@@ -83,20 +73,20 @@ async fn main() {
         _ = terminate => {},
     }
 
-    tracing::info!("Stopped cloudmon-metrics-reporting");
+    tracing::info!("stopped cloudmon-metrics-reporter");
 }
 
 async fn metric_watcher(config: &Config) {
-    tracing::info!("Starting metric reporter thread");
+    tracing::info!("starting metric reporter thread");
     // Init reqwest client
     let req_client: reqwest::Client = ClientBuilder::new()
-        .timeout(Duration::from_secs(2 as u64))
+        .timeout(Duration::from_secs(CLIENT_TIMEOUT_SECS))
         .build()
         .unwrap();
     // Endless loop
     let mut components: HashMap<String, HashMap<String, Component>> = HashMap::new();
     for env in config.environments.iter() {
-        let comp_env_entry = components.entry(env.name.clone()).or_insert(HashMap::new());
+        let comp_env_entry = components.entry(env.name.clone()).or_default();
         let mut env_attrs: Vec<ComponentAttribute> = Vec::new();
         if let Some(ref attrs) = env.attributes {
             for (key, val) in attrs.iter() {
@@ -128,16 +118,68 @@ async fn metric_watcher(config: &Config) {
         .status_dashboard
         .as_ref()
         .expect("Status dashboard section is missing");
-    let status_report_url = format!("{}/v1/component_status", sdb_config.url.clone(),);
-    let mut headers = HeaderMap::new();
-    if let Some(ref secret) = sdb_config.secret {
-        let key: Hmac<Sha256> = Hmac::new_from_slice(secret.as_bytes()).unwrap();
-        let mut claims = BTreeMap::new();
-        claims.insert("stackmon", "dummy");
-        let token_str = claims.sign_with_key(&key).unwrap();
-        let bearer = format!("Bearer {}", token_str);
-        headers.insert(AUTHORIZATION, bearer.parse().unwrap());
+
+    // Build authorization headers using status_dashboard module (T021, T022, T023 - US3)
+    // VERIFIED: Existing HMAC-JWT mechanism works unchanged with V2 endpoints
+    let headers = build_auth_headers(sdb_config.secret.as_deref());
+
+    // Initialize component ID cache at startup with retry logic (T024, T025, T026, T027)
+    // Per FR-006: 3 retry attempts with 60-second delays
+    // Per FR-007: Fail to start if all attempts fail
+    let mut component_cache = None;
+    let max_attempts = 3;
+
+    for attempt in 1..=max_attempts {
+        tracing::info!(
+            attempt = attempt,
+            max_attempts = max_attempts,
+            "attempting to fetch components from Status Dashboard"
+        );
+
+        match fetch_components(&req_client, &sdb_config.url, &headers).await {
+            Ok(components) => {
+                tracing::info!(
+                    attempt = attempt,
+                    component_count = components.len(),
+                    "successfully fetched components from Status Dashboard"
+                );
+                component_cache = Some(build_component_id_cache(components));
+                break;
+            }
+            Err(e) => {
+                // T027: Warning logging for each failed attempt with attempt number
+                if attempt < max_attempts {
+                    tracing::warn!(
+                        error = %e,
+                        attempt = attempt,
+                        max_attempts = max_attempts,
+                        retry_delay_seconds = 60,
+                        "failed to fetch components, will retry after delay"
+                    );
+                    // T025: 60-second delay between retry attempts
+                    sleep(Duration::from_secs(60)).await;
+                } else {
+                    // T026: Final failure after all attempts
+                    tracing::error!(
+                        error = %e,
+                        attempt = attempt,
+                        max_attempts = max_attempts,
+                        "failed to fetch components after all retry attempts, reporter cannot start"
+                    );
+                }
+            }
+        }
     }
+
+    // T026: Error return from metric_watcher if cache load fails per FR-007
+    let mut component_cache = match component_cache {
+        Some(cache) => cache,
+        None => {
+            tracing::error!("component cache initialization failed, exiting metric_watcher");
+            return;
+        }
+    };
+
     loop {
         // For every env from config
         for env in config.environments.iter() {
@@ -145,18 +187,18 @@ async fn metric_watcher(config: &Config) {
             // For every component (health_metric service)
             for component in config.health_metrics.iter() {
                 tracing::trace!("Component {:?}", component.0);
-                // Query metric-convertor for the status
+                // Query metric-convertor for the status (includes metric states and matched expression)
                 match req_client
                     .get(format!(
                         "http://localhost:{}/api/v1/health",
                         config.server.port
                     ))
-                    // Query env/service for time [-2min..-1min]
+                    // Query env/service for time [query_from...query_to]
                     .query(&[
                         ("environment", env.name.clone()),
                         ("service", component.0.clone()),
-                        ("from", "-5min".to_string()),
-                        ("to", "-2min".to_string()),
+                        ("from", config.health_query.query_from.clone()),
+                        ("to", config.health_query.query_to.clone()),
                     ])
                     .send()
                     .await
@@ -171,42 +213,133 @@ async fn metric_watcher(config: &Config) {
                                     tracing::debug!("response {:?}", data);
                                     // Peek at last metric in the vector
                                     if let Some(last) = data.metrics.pop() {
-                                        // Is metric showing issues?
-                                        if last.1 > 0 {
-                                            tracing::info!("Bad status found: {}", last.1);
-                                            let component = components
+                                        // Is metric showing issues? (weight > 0 means degraded or outage)
+                                        let impact = last.weight;
+                                        if impact > 0 {
+                                            let comp = components
                                                 .get(&env.name)
                                                 .unwrap()
                                                 .get(component.0)
                                                 .unwrap();
-                                            tracing::info!("Component to report: {:?}", component);
-                                            let body = ComponentStatus {
-                                                name: component.name.clone(),
-                                                impact: last.1,
-                                                attributes: component.attributes.clone(),
-                                            };
-                                            let res = req_client
-                                                .post(&status_report_url)
-                                                .headers(headers.clone())
-                                                .json(&body)
-                                                .send()
-                                                .await;
-                                            match res {
-                                                Ok(rsp) => {
-                                                    if rsp.status().is_client_error() {
-                                                        tracing::error!(
-                                                            "Error: [{}] {:?}",
-                                                            rsp.status(),
-                                                            rsp.text().await
+
+                                            // T017: Find component ID in cache (cache miss detection)
+                                            let mut component_id =
+                                                find_component_id(&component_cache, comp);
+
+                                            // T018: If component not found, refresh cache once per FR-005
+                                            if component_id.is_none() {
+                                                tracing::info!(
+                                                    component_name = comp.name.as_str(),
+                                                    service = component.0.as_str(),
+                                                    environment = env.name.as_str(),
+                                                    "component not found in cache, attempting cache refresh"
+                                                );
+
+                                                match fetch_components(
+                                                    &req_client,
+                                                    &sdb_config.url,
+                                                    &headers,
+                                                )
+                                                .await
+                                                {
+                                                    Ok(components) => {
+                                                        tracing::info!(
+                                                            component_count = components.len(),
+                                                            "cache refreshed"
+                                                        );
+                                                        component_cache =
+                                                            build_component_id_cache(components);
+                                                        // Retry lookup after refresh
+                                                        component_id = find_component_id(
+                                                            &component_cache,
+                                                            comp,
+                                                        );
+                                                    }
+                                                    Err(e) => {
+                                                        tracing::warn!(
+                                                            error = %e,
+                                                            component_name = comp.name.as_str(),
+                                                            "failed to refresh component cache"
                                                         );
                                                     }
                                                 }
+                                            }
+
+                                            // Process component if found
+                                            match component_id {
+                                                Some(id) => {
+                                                    // Build incident data with impact for Status Dashboard
+                                                    let incident_data = build_incident_data(
+                                                        id,
+                                                        impact,
+                                                        last.timestamp as i64,
+                                                    );
+
+                                                    // Format triggered metric details for logging
+                                                    let triggered_metrics: Vec<String> = last
+                                                        .triggered_metric_details
+                                                        .iter()
+                                                        .map(|m| {
+                                                            format!(
+                                                                "{}(query={}, op={}, threshold={})",
+                                                                m.name, m.query, m.op, m.threshold
+                                                            )
+                                                        })
+                                                        .collect();
 
-                                                Err(e) => {
-                                                    tracing::error!(
-                                                        "Error during posting component status: {}",
-                                                        e
+                                                    // Include full decision context: query parameters, metric details, matched expression
+                                                    tracing::info!(
+                                                        environment = env.name.as_str(),
+                                                        service = component.0.as_str(),
+                                                        component_name = comp.name.as_str(),
+                                                        component_id = id,
+                                                        query_from = config.health_query.query_from.as_str(),
+                                                        query_to = config.health_query.query_to.as_str(),
+                                                        metric_timestamp = last.timestamp,
+                                                        impact = impact,
+                                                        triggered_metrics = ?triggered_metrics,
+                                                        matched_expression = last.matched_expression.as_deref().unwrap_or("none"),
+                                                        "creating incident: health metric indicates service degradation"
+                                                    );
+
+                                                    // Create incident via V2 API
+                                                    match create_incident(
+                                                        &req_client,
+                                                        &sdb_config.url,
+                                                        &headers,
+                                                        &incident_data,
+                                                    )
+                                                    .await
+                                                    {
+                                                        Ok(_) => {
+                                                            tracing::info!(
+                                                                component_id = id,
+                                                                impact = impact,
+                                                                "incident created successfully"
+                                                            );
+                                                        }
+                                                        Err(e) => {
+                                                            // Error logging with details (FR-015)
+                                                            tracing::error!(
+                                                                error = %e,
+                                                                component_id = id,
+                                                                service = component.0.as_str(),
+                                                                environment = env.name.as_str(),
+                                                                "failed to create incident"
+                                                            );
+                                                        }
+                                                    }
+                                                }
+                                                None => {
+                                                    // T019, T020: Warning logging and continue to next service
+                                                    tracing::warn!(
+                                                        component_name = comp.name.as_str(),
+                                                        service = component.0.as_str(),
+                                                        environment = env.name.as_str(),
+                                                        "component not found in cache even after refresh, skipping incident creation"
                                                     );
+                                                    // Continue to next service (no retry on incident creation)
+                                                    continue;
                                                 }
                                             }
                                         }
diff --git a/src/common.rs b/src/common.rs
index 32ef36d..9adeae7 100644
--- a/src/common.rs
+++ b/src/common.rs
@@ -1,6 +1,9 @@
 //! Common methods
 //!
-use crate::types::{AppState, CloudMonError, CmpType, FlagMetric, ServiceHealthData};
+use crate::types::{
+    AppState, CloudMonError, CmpType, FlagMetric, MetricDetail, ServiceHealthData,
+    ServiceHealthDataPoint,
+};
 use chrono::DateTime;
 use evalexpr::*;
 use std::collections::{BTreeMap, HashMap};
@@ -10,14 +13,14 @@ use crate::graphite;
 /// Get Flag value for the metric
 pub fn get_metric_flag_state(value: &Option<f32>, metric: &FlagMetric) -> bool {
     // Convert raw value to flag
-    return match *value {
+    match *value {
         Some(x) => match metric.op {
             CmpType::Lt => x < metric.threshold,
             CmpType::Gt => x > metric.threshold,
             CmpType::Eq => x == metric.threshold,
         },
         None => false,
-    };
+    }
 }
 /// Get Service Health as described by config
 pub async fn get_service_health(
@@ -32,7 +35,7 @@ pub async fn get_service_health(
         return Err(CloudMonError::ServiceNotSupported);
     }
     let hm_config = state.health_metrics.get(service).unwrap();
-    let metric_names: Vec<String> = Vec::from(hm_config.metrics.clone());
+    let metric_names: Vec<String> = hm_config.metrics.clone();
 
     tracing::trace!("Requesting metrics {:?}", metric_names);
     let mut graphite_targets: HashMap<String, String> = HashMap::new();
@@ -57,7 +60,7 @@ pub async fn get_service_health(
     tracing::debug!("Requesting Graphite {:?}", graphite_targets);
     let raw_data: Vec<graphite::GraphiteData> = graphite::get_graphite_data(
         &state.req_client,
-        &state.config.datasource.url.as_str(),
+        state.config.datasource.url.as_str(),
         &graphite_targets,
         DateTime::parse_from_rfc3339(from).ok(),
         Some(from.to_string()),
@@ -65,8 +68,7 @@ pub async fn get_service_health(
         Some(to.to_string()),
         max_data_points,
     )
-    .await
-    .unwrap();
+    .await?;
 
     tracing::trace!("Response from Graphite {:?}", raw_data);
 
@@ -84,8 +86,8 @@ pub async fn get_service_health(
                 // Iterate over all fetched series
                 for (val, ts) in data_element.datapoints.iter() {
                     // Convert raw value to flag
-                    if let Some(_) = val {
-                        metrics_map.entry(*ts).or_insert(HashMap::new()).insert(
+                    if val.is_some() {
+                        metrics_map.entry(*ts).or_default().insert(
                             data_element.target.clone(),
                             get_metric_flag_state(val, metric),
                         );
@@ -113,13 +115,14 @@ pub async fn get_service_health(
                 _ => false,
             };
             context
-                .set_value(metric.replace("-", "_").into(), Value::from(xval))
+                .set_value(metric.replace("-", "_"), Value::from(xval))
                 .unwrap();
         }
         let mut expression_res: u8 = 0;
+        let mut matched_expression: Option<String> = None;
         // loop over all expressions
         for expr in hm_config.expressions.iter() {
-            // if expression weight is lower then what we have already - skip
+            // if expression weight is lower than what we have already - skip
             if expr.weight as u8 <= expression_res {
                 continue;
             }
@@ -127,6 +130,7 @@ pub async fn get_service_health(
                 Ok(m) => {
                     if m {
                         expression_res = expr.weight as u8;
+                        matched_expression = Some(expr.expression.clone());
                         tracing::debug!(
                             "Summary of evaluation expression for service: {:?}, expression: {:?}, weight: {:?}",
                             service,
@@ -146,18 +150,44 @@ pub async fn get_service_health(
                 }
             }
         }
-        result.push((*ts, expression_res));
+
+        // Build triggered metric details for metrics with state=true
+        let triggered_metric_details: Vec<MetricDetail> = ts_val
+            .iter()
+            .filter(|(_, &state)| state) // Only triggered (true) metrics
+            .filter_map(|(metric_name, _)| {
+                // Look up the metric definition
+                state.flag_metrics.get(metric_name).and_then(|metric_cfg| {
+                    metric_cfg.get(environment).map(|metric| MetricDetail {
+                        name: metric_name.clone(),
+                        query: metric.query.clone(),
+                        op: format!("{:?}", metric.op).to_lowercase(),
+                        threshold: metric.threshold,
+                    })
+                })
+            })
+            .collect();
+
+        result.push(ServiceHealthDataPoint {
+            timestamp: *ts,
+            weight: expression_res,
+            metric_states: ts_val.clone(),
+            matched_expression,
+            triggered_metric_details,
+        });
     }
 
     tracing::debug!("Summary data: {:?}, length={}", result, result.len());
 
-    return Ok(result);
+    Ok(result)
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::types::{CmpType, FlagMetric, EnvironmentDef, MetricExpressionDef, ServiceHealthDef};
+    use crate::types::{
+        CmpType, EnvironmentDef, FlagMetric, MetricExpressionDef, ServiceHealthDef,
+    };
 
     // Helper function to create a test metric
     fn create_test_metric(op: CmpType, threshold: f32) -> FlagMetric {
@@ -181,16 +211,22 @@ mod tests {
     #[test]
     fn test_lt_operator_above_or_equal_threshold() {
         let metric = create_test_metric(CmpType::Lt, 10.0);
-        
+
         // Test equal
         let value = Some(10.0);
         let result = get_metric_flag_state(&value, &metric);
-        assert_eq!(result, false, "Lt operator: 10.0 < 10.0 should return false");
-        
+        assert_eq!(
+            result, false,
+            "Lt operator: 10.0 < 10.0 should return false"
+        );
+
         // Test above
         let value = Some(15.0);
         let result = get_metric_flag_state(&value, &metric);
-        assert_eq!(result, false, "Lt operator: 15.0 < 10.0 should return false");
+        assert_eq!(
+            result, false,
+            "Lt operator: 15.0 < 10.0 should return false"
+        );
     }
 
     // T012: Test Gt operator with value > threshold returns true
@@ -206,12 +242,15 @@ mod tests {
     #[test]
     fn test_gt_operator_below_or_equal_threshold() {
         let metric = create_test_metric(CmpType::Gt, 10.0);
-        
+
         // Test equal
         let value = Some(10.0);
         let result = get_metric_flag_state(&value, &metric);
-        assert_eq!(result, false, "Gt operator: 10.0 > 10.0 should return false");
-        
+        assert_eq!(
+            result, false,
+            "Gt operator: 10.0 > 10.0 should return false"
+        );
+
         // Test below
         let value = Some(5.0);
         let result = get_metric_flag_state(&value, &metric);
@@ -231,44 +270,59 @@ mod tests {
     #[test]
     fn test_eq_operator_not_equal_threshold() {
         let metric = create_test_metric(CmpType::Eq, 10.0);
-        
+
         // Test below
         let value = Some(5.0);
         let result = get_metric_flag_state(&value, &metric);
-        assert_eq!(result, false, "Eq operator: 5.0 == 10.0 should return false");
-        
+        assert_eq!(
+            result, false,
+            "Eq operator: 5.0 == 10.0 should return false"
+        );
+
         // Test above
         let value = Some(15.0);
         let result = get_metric_flag_state(&value, &metric);
-        assert_eq!(result, false, "Eq operator: 15.0 == 10.0 should return false");
+        assert_eq!(
+            result, false,
+            "Eq operator: 15.0 == 10.0 should return false"
+        );
     }
 
     // T016: Test None value always returns false for all operators
     #[test]
     fn test_none_value_returns_false() {
         let value = None;
-        
+
         // Test with Lt operator
         let metric = create_test_metric(CmpType::Lt, 10.0);
         let result = get_metric_flag_state(&value, &metric);
-        assert_eq!(result, false, "Lt operator with None value should return false");
-        
+        assert_eq!(
+            result, false,
+            "Lt operator with None value should return false"
+        );
+
         // Test with Gt operator
         let metric = create_test_metric(CmpType::Gt, 10.0);
         let result = get_metric_flag_state(&value, &metric);
-        assert_eq!(result, false, "Gt operator with None value should return false");
-        
+        assert_eq!(
+            result, false,
+            "Gt operator with None value should return false"
+        );
+
         // Test with Eq operator
         let metric = create_test_metric(CmpType::Eq, 10.0);
         let result = get_metric_flag_state(&value, &metric);
-        assert_eq!(result, false, "Eq operator with None value should return false");
+        assert_eq!(
+            result, false,
+            "Eq operator with None value should return false"
+        );
     }
 
     // T017: Test boundary conditions (threshold ± 0.001)
     #[test]
     fn test_boundary_conditions() {
         let threshold = 10.0;
-        
+
         // Lt operator with boundaries
         let metric = create_test_metric(CmpType::Lt, threshold);
         let value_below = Some(threshold - 0.001);
@@ -277,14 +331,14 @@ mod tests {
             true,
             "Lt operator: value just below threshold should return true"
         );
-        
+
         let value_above = Some(threshold + 0.001);
         assert_eq!(
             get_metric_flag_state(&value_above, &metric),
             false,
             "Lt operator: value just above threshold should return false"
         );
-        
+
         // Gt operator with boundaries
         let metric = create_test_metric(CmpType::Gt, threshold);
         let value_above = Some(threshold + 0.001);
@@ -293,7 +347,7 @@ mod tests {
             true,
             "Gt operator: value just above threshold should return true"
         );
-        
+
         let value_below = Some(threshold - 0.001);
         assert_eq!(
             get_metric_flag_state(&value_below, &metric),
@@ -322,7 +376,7 @@ mod tests {
             false,
             "Lt: 0.0 < -5.0 should return false"
         );
-        
+
         // Gt operator with negative values
         let metric = create_test_metric(CmpType::Gt, -5.0);
         assert_eq!(
@@ -340,7 +394,7 @@ mod tests {
             false,
             "Gt: -10.0 > -5.0 should return false"
         );
-        
+
         // Eq operator with negative values
         let metric = create_test_metric(CmpType::Eq, -5.0);
         assert_eq!(
@@ -359,7 +413,7 @@ mod tests {
     #[test]
     fn test_zero_threshold() {
         let threshold = 0.0;
-        
+
         // Lt operator with zero threshold
         let metric = create_test_metric(CmpType::Lt, threshold);
         assert_eq!(
@@ -377,7 +431,7 @@ mod tests {
             false,
             "Lt: 1.0 < 0.0 should return false"
         );
-        
+
         // Gt operator with zero threshold
         let metric = create_test_metric(CmpType::Gt, threshold);
         assert_eq!(
@@ -395,7 +449,7 @@ mod tests {
             false,
             "Gt: -1.0 > 0.0 should return false"
         );
-        
+
         // Eq operator with zero threshold
         let metric = create_test_metric(CmpType::Eq, threshold);
         assert_eq!(
@@ -417,7 +471,7 @@ mod tests {
         let lt_metric = create_test_metric(CmpType::Lt, 50.0);
         let gt_metric = create_test_metric(CmpType::Gt, 10.0);
         let eq_metric = create_test_metric(CmpType::Eq, 42.0);
-        
+
         // Test value that satisfies Lt condition
         let value = Some(30.0);
         assert_eq!(
@@ -435,7 +489,7 @@ mod tests {
             false,
             "30.0 == 42.0 should be false"
         );
-        
+
         // Test value that satisfies Eq condition
         let value = Some(42.0);
         assert_eq!(
@@ -453,7 +507,7 @@ mod tests {
             true,
             "42.0 == 42.0 should be true"
         );
-        
+
         // Test value that fails all conditions
         let value = Some(5.0);
         assert_eq!(
@@ -481,8 +535,8 @@ mod tests {
         expressions: Vec<(&str, i32)>,
         graphite_url: &str,
     ) -> AppState {
-        use crate::config::{Config, Datasource, ServerConf};
-        
+        use crate::config::{Config, Datasource, HealthQueryConfig, ServerConf};
+
         let config = Config {
             datasource: Datasource {
                 url: graphite_url.to_string(),
@@ -500,10 +554,11 @@ mod tests {
                 attributes: None,
             }],
             status_dashboard: None,
+            health_query: HealthQueryConfig::default(),
         };
 
         let mut state = AppState::new(config);
-        
+
         // Setup flag metrics and collect metric names
         let mut metric_names = Vec::new();
         for (name, op, threshold) in metrics {
@@ -520,7 +575,7 @@ mod tests {
             );
             state.flag_metrics.insert(metric_key, env_map);
         }
-        
+
         // Setup health metrics
         let expression_defs: Vec<MetricExpressionDef> = expressions
             .into_iter()
@@ -529,7 +584,7 @@ mod tests {
                 weight,
             })
             .collect();
-        
+
         state.health_metrics.insert(
             service.to_string(),
             ServiceHealthDef {
@@ -540,7 +595,7 @@ mod tests {
                 expressions: expression_defs,
             },
         );
-        
+
         state.services.insert(service.to_string());
         state
     }
@@ -549,10 +604,10 @@ mod tests {
     #[tokio::test]
     async fn test_single_metric_or_expression() {
         use mockito;
-        
+
         let mut server = mockito::Server::new_async().await;
         let mock_url = server.url();
-        
+
         // Setup: single metric "error_rate" with Lt 5.0
         let state = create_health_test_state(
             "test-service",
@@ -561,18 +616,19 @@ mod tests {
             vec![("test_service.error_rate", 100)], // Weight 100 if error_rate flag is true
             &mock_url,
         );
-        
+
         // Mock Graphite response: error_rate = 2.0 (< 5.0, so flag = true)
         let _mock = server
             .mock("GET", "/render")
-            .match_query(mockito::Matcher::AllOf(vec![
-                mockito::Matcher::UrlEncoded("format".into(), "json".into()),
-            ]))
+            .match_query(mockito::Matcher::AllOf(vec![mockito::Matcher::UrlEncoded(
+                "format".into(),
+                "json".into(),
+            )]))
             .with_status(200)
             .with_header("content-type", "application/json")
             .with_body(r#"[{"target":"test-service.error_rate","datapoints":[[2.0,1234567890]]}]"#)
             .create();
-        
+
         let result = get_service_health(
             &state,
             "test-service",
@@ -582,24 +638,31 @@ mod tests {
             100,
         )
         .await;
-        
+
         if let Err(ref e) = result {
             eprintln!("Error from get_service_health: {:?}", e);
         }
-        assert!(result.is_ok(), "Single metric OR expression should succeed: {:?}", result);
+        assert!(
+            result.is_ok(),
+            "Single metric OR expression should succeed: {:?}",
+            result
+        );
         let health_data = result.unwrap();
         assert_eq!(health_data.len(), 1, "Should have one datapoint");
-        assert_eq!(health_data[0].1, 100, "Expression weight 100 should be returned when flag is true");
+        assert_eq!(
+            health_data[0].weight, 100,
+            "Expression weight 100 should be returned when flag is true"
+        );
     }
 
     // T027: Test two metrics AND expression (both true)
     #[tokio::test]
     async fn test_two_metrics_and_both_true() {
         use mockito;
-        
+
         let mut server = mockito::Server::new_async().await;
         let mock_url = server.url();
-        
+
         // Setup: two metrics with AND expression
         let state = create_health_test_state(
             "test-service",
@@ -611,13 +674,14 @@ mod tests {
             vec![("test_service.error_rate && test_service.response_time", 100)],
             &mock_url,
         );
-        
+
         // Mock Graphite response: both metrics satisfy thresholds
         let _mock = server
             .mock("GET", "/render")
-            .match_query(mockito::Matcher::AllOf(vec![
-                mockito::Matcher::UrlEncoded("format".into(), "json".into()),
-            ]))
+            .match_query(mockito::Matcher::AllOf(vec![mockito::Matcher::UrlEncoded(
+                "format".into(),
+                "json".into(),
+            )]))
             .with_status(200)
             .with_header("content-type", "application/json")
             .with_body(
@@ -627,7 +691,7 @@ mod tests {
                 ]"#,
             )
             .create();
-        
+
         let result = get_service_health(
             &state,
             "test-service",
@@ -637,12 +701,16 @@ mod tests {
             100,
         )
         .await;
-        
-        assert!(result.is_ok(), "Two metrics AND expression (both true) should succeed: {:?}", result);
+
+        assert!(
+            result.is_ok(),
+            "Two metrics AND expression (both true) should succeed: {:?}",
+            result
+        );
         let health_data = result.unwrap();
         assert_eq!(health_data.len(), 1, "Should have one datapoint");
         assert_eq!(
-            health_data[0].1, 100,
+            health_data[0].weight, 100,
             "AND expression should return weight 100 when both flags are true"
         );
     }
@@ -651,10 +719,10 @@ mod tests {
     #[tokio::test]
     async fn test_two_metrics_and_one_false() {
         use mockito;
-        
+
         let mut server = mockito::Server::new_async().await;
         let mock_url = server.url();
-        
+
         // Setup: two metrics with AND expression
         let state = create_health_test_state(
             "test-service",
@@ -666,13 +734,14 @@ mod tests {
             vec![("test_service.error_rate && test_service.response_time", 100)],
             &mock_url,
         );
-        
+
         // Mock Graphite response: error_rate OK but response_time too high
         let _mock = server
             .mock("GET", "/render")
-            .match_query(mockito::Matcher::AllOf(vec![
-                mockito::Matcher::UrlEncoded("format".into(), "json".into()),
-            ]))
+            .match_query(mockito::Matcher::AllOf(vec![mockito::Matcher::UrlEncoded(
+                "format".into(),
+                "json".into(),
+            )]))
             .with_status(200)
             .with_header("content-type", "application/json")
             .with_body(
@@ -682,7 +751,7 @@ mod tests {
                 ]"#,
             )
             .create();
-        
+
         let result = get_service_health(
             &state,
             "test-service",
@@ -692,12 +761,15 @@ mod tests {
             100,
         )
         .await;
-        
-        assert!(result.is_ok(), "Two metrics AND expression (one false) should succeed");
+
+        assert!(
+            result.is_ok(),
+            "Two metrics AND expression (one false) should succeed"
+        );
         let health_data = result.unwrap();
         assert_eq!(health_data.len(), 1, "Should have one datapoint");
         assert_eq!(
-            health_data[0].1, 0,
+            health_data[0].weight, 0,
             "AND expression should return weight 0 when one flag is false"
         );
     }
@@ -706,10 +778,10 @@ mod tests {
     #[tokio::test]
     async fn test_weighted_expressions_highest_weight() {
         use mockito;
-        
+
         let mut server = mockito::Server::new_async().await;
         let mock_url = server.url();
-        
+
         // Setup: multiple expressions with different weights
         let state = create_health_test_state(
             "test-service",
@@ -719,19 +791,20 @@ mod tests {
                 ("response_time", CmpType::Lt, 100.0),
             ],
             vec![
-                ("test_service.error_rate", 50),     // Weight 50 if only error_rate
-                ("test_service.response_time", 30),  // Weight 30 if only response_time
+                ("test_service.error_rate", 50),    // Weight 50 if only error_rate
+                ("test_service.response_time", 30), // Weight 30 if only response_time
                 ("test_service.error_rate && test_service.response_time", 100), // Weight 100 if both
             ],
             &mock_url,
         );
-        
+
         // Mock Graphite response: both flags are true
         let _mock = server
             .mock("GET", "/render")
-            .match_query(mockito::Matcher::AllOf(vec![
-                mockito::Matcher::UrlEncoded("format".into(), "json".into()),
-            ]))
+            .match_query(mockito::Matcher::AllOf(vec![mockito::Matcher::UrlEncoded(
+                "format".into(),
+                "json".into(),
+            )]))
             .with_status(200)
             .with_header("content-type", "application/json")
             .with_body(
@@ -741,7 +814,7 @@ mod tests {
                 ]"#,
             )
             .create();
-        
+
         let result = get_service_health(
             &state,
             "test-service",
@@ -751,12 +824,12 @@ mod tests {
             100,
         )
         .await;
-        
+
         assert!(result.is_ok(), "Weighted expressions should succeed");
         let health_data = result.unwrap();
         assert_eq!(health_data.len(), 1, "Should have one datapoint");
         assert_eq!(
-            health_data[0].1, 100,
+            health_data[0].weight, 100,
             "Should return highest matching weight (100)"
         );
     }
@@ -765,10 +838,10 @@ mod tests {
     #[tokio::test]
     async fn test_all_false_expressions_return_zero() {
         use mockito;
-        
+
         let mut server = mockito::Server::new_async().await;
         let mock_url = server.url();
-        
+
         // Setup: expressions that require flags to be true
         let state = create_health_test_state(
             "test-service",
@@ -777,18 +850,17 @@ mod tests {
                 ("error_rate", CmpType::Lt, 5.0),
                 ("response_time", CmpType::Lt, 100.0),
             ],
-            vec![
-                ("test_service.error_rate && test_service.response_time", 100),
-            ],
+            vec![("test_service.error_rate && test_service.response_time", 100)],
             &mock_url,
         );
-        
+
         // Mock Graphite response: both flags are false
         let _mock = server
             .mock("GET", "/render")
-            .match_query(mockito::Matcher::AllOf(vec![
-                mockito::Matcher::UrlEncoded("format".into(), "json".into()),
-            ]))
+            .match_query(mockito::Matcher::AllOf(vec![mockito::Matcher::UrlEncoded(
+                "format".into(),
+                "json".into(),
+            )]))
             .with_status(200)
             .with_header("content-type", "application/json")
             .with_body(
@@ -798,7 +870,7 @@ mod tests {
                 ]"#,
             )
             .create();
-        
+
         let result = get_service_health(
             &state,
             "test-service",
@@ -808,12 +880,12 @@ mod tests {
             100,
         )
         .await;
-        
+
         assert!(result.is_ok(), "All false expressions should succeed");
         let health_data = result.unwrap();
         assert_eq!(health_data.len(), 1, "Should have one datapoint");
         assert_eq!(
-            health_data[0].1, 0,
+            health_data[0].weight, 0,
             "Should return weight 0 when all expressions are false"
         );
     }
@@ -822,10 +894,10 @@ mod tests {
     #[tokio::test]
     async fn test_unknown_service_error() {
         use mockito;
-        
+
         let server = mockito::Server::new_async().await;
         let mock_url = server.url();
-        
+
         let state = create_health_test_state(
             "test-service",
             "production",
@@ -833,7 +905,7 @@ mod tests {
             vec![("test_service.error_rate", 100)],
             &mock_url,
         );
-        
+
         let result = get_service_health(
             &state,
             "unknown-service", // Request a service that doesn't exist
@@ -843,7 +915,7 @@ mod tests {
             100,
         )
         .await;
-        
+
         assert!(result.is_err(), "Unknown service should return error");
         match result.unwrap_err() {
             CloudMonError::ServiceNotSupported => {
@@ -857,10 +929,10 @@ mod tests {
     #[tokio::test]
     async fn test_unknown_environment_error() {
         use mockito;
-        
+
         let server = mockito::Server::new_async().await;
         let mock_url = server.url();
-        
+
         let state = create_health_test_state(
             "test-service",
             "production",
@@ -868,7 +940,7 @@ mod tests {
             vec![("test_service.error_rate", 100)],
             &mock_url,
         );
-        
+
         let result = get_service_health(
             &state,
             "test-service",
@@ -878,7 +950,7 @@ mod tests {
             100,
         )
         .await;
-        
+
         assert!(result.is_err(), "Unknown environment should return error");
         match result.unwrap_err() {
             CloudMonError::EnvNotSupported => {
@@ -892,10 +964,10 @@ mod tests {
     #[tokio::test]
     async fn test_multiple_datapoints_time_series() {
         use mockito;
-        
+
         let mut server = mockito::Server::new_async().await;
         let mock_url = server.url();
-        
+
         let state = create_health_test_state(
             "test-service",
             "production",
@@ -903,13 +975,14 @@ mod tests {
             vec![("test_service.error_rate", 100)],
             &mock_url,
         );
-        
+
         // Mock Graphite response: multiple datapoints over time
         let _mock = server
             .mock("GET", "/render")
-            .match_query(mockito::Matcher::AllOf(vec![
-                mockito::Matcher::UrlEncoded("format".into(), "json".into()),
-            ]))
+            .match_query(mockito::Matcher::AllOf(vec![mockito::Matcher::UrlEncoded(
+                "format".into(),
+                "json".into(),
+            )]))
             .with_status(200)
             .with_header("content-type", "application/json")
             .with_body(
@@ -924,7 +997,7 @@ mod tests {
                 }]"#,
             )
             .create();
-        
+
         let result = get_service_health(
             &state,
             "test-service",
@@ -934,7 +1007,7 @@ mod tests {
             100,
         )
         .await;
-        
+
         assert!(result.is_ok(), "Multiple datapoints should succeed");
         let health_data = result.unwrap();
         assert_eq!(
@@ -942,11 +1015,11 @@ mod tests {
             4,
             "Should have four datapoints (one per timestamp)"
         );
-        
+
         // All values are < 5.0, so all should have weight 100
-        for (i, (_, weight)) in health_data.iter().enumerate() {
+        for (i, data_point) in health_data.iter().enumerate() {
             assert_eq!(
-                *weight, 100,
+                data_point.weight, 100,
                 "Datapoint {} should have weight 100",
                 i
             );
@@ -960,22 +1033,26 @@ mod tests {
         use mockito::Matcher;
 
         let mut server = mockito::Server::new();
-        
+
         // Mock Graphite to return valid data
         let _mock = server
             .mock("GET", "/render")
             .match_query(Matcher::Any)
             .with_status(200)
             .with_header("content-type", "application/json")
-            .with_body(serde_json::json!([
-                {
-                    "target": "svc1.metric1",
-                    "datapoints": [[15.0, 1609459200]]
-                }
-            ]).to_string())
+            .with_body(
+                serde_json::json!([
+                    {
+                        "target": "svc1.metric1",
+                        "datapoints": [[15.0, 1609459200]]
+                    }
+                ])
+                .to_string(),
+            )
             .create();
 
-        let config_str = format!("
+        let config_str = format!(
+            "
         datasource:
           url: '{}'
         server:
@@ -1003,24 +1080,21 @@ mod tests {
             expressions:
               - expression: 'invalid syntax &&& broken'
                 weight: 1
-        ", server.url());
+        ",
+            server.url()
+        );
 
         let config = crate::config::Config::from_config_str(&config_str);
-        let mut state = crate::types::AppState::new(config);
+        let mut state = AppState::new(config);
         state.process_config();
 
         // Call get_service_health with invalid expression
-        let result = get_service_health(
-            &state,
-            "svc1",
-            "prod",
-            "now-1h",
-            "now",
-            10
-        ).await;
+        let result = get_service_health(&state, "svc1", "prod", "now-1h", "now", 10).await;
 
         // Should return ExpressionError
-        assert!(result.is_err(), "Should return error for invalid expression");
+        assert!(
+            result.is_err(),
+            "Should return error for invalid expression"
+        );
     }
 }
-
diff --git a/src/config.rs b/src/config.rs
index aa0d171..350b2cc 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -37,6 +37,7 @@
 
 use glob::glob;
 
+use schemars::JsonSchema;
 use serde::Deserialize;
 use std::{
     collections::HashMap,
@@ -49,7 +50,7 @@ use config::{ConfigError, Environment, File};
 use crate::types::{BinaryMetricRawDef, EnvironmentDef, FlagMetricDef, ServiceHealthDef};
 
 /// A Configuration structure
-#[derive(Clone, Debug, Deserialize)]
+#[derive(Clone, Debug, Deserialize, JsonSchema)]
 pub struct Config {
     /// Datasource link
     pub datasource: Datasource,
@@ -65,6 +66,9 @@ pub struct Config {
     pub health_metrics: HashMap<String, ServiceHealthDef>,
     /// Status Dashboard connection
     pub status_dashboard: Option<StatusDashboardConfig>,
+    /// Health metrics query configuration
+    #[serde(default)]
+    pub health_query: HealthQueryConfig,
 }
 
 impl Config {
@@ -126,7 +130,7 @@ impl Config {
 }
 
 /// TSDB Datasource connection
-#[derive(Clone, Debug, Deserialize)]
+#[derive(Clone, Debug, Deserialize, JsonSchema)]
 pub struct Datasource {
     /// TSDB url
     pub url: String,
@@ -136,7 +140,7 @@ pub struct Datasource {
 }
 
 /// Server binding configuration
-#[derive(Clone, Debug, Deserialize)]
+#[derive(Clone, Debug, Deserialize, JsonSchema)]
 pub struct ServerConf {
     /// IP address to bind to
     #[serde(default = "default_address")]
@@ -159,7 +163,7 @@ fn default_timeout() -> u16 {
 }
 
 /// TSDB supported types enum
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Deserialize, JsonSchema)]
 #[serde(rename_all = "lowercase")]
 pub enum DatasourceType {
     /// Graphite
@@ -167,7 +171,7 @@ pub enum DatasourceType {
 }
 
 /// Status Dashboard configuration
-#[derive(Clone, Debug, Deserialize)]
+#[derive(Clone, Debug, Deserialize, JsonSchema)]
 pub struct StatusDashboardConfig {
     /// Status dashboard URL
     pub url: String,
@@ -175,10 +179,39 @@ pub struct StatusDashboardConfig {
     pub secret: Option<String>,
 }
 
+/// Health metrics query configuration
+#[derive(Clone, Debug, Deserialize, JsonSchema)]
+pub struct HealthQueryConfig {
+    /// Query start time offset for health metrics (e.g., "-5min")
+    #[serde(default = "default_query_from")]
+    pub query_from: String,
+    /// Query end time offset for health metrics (e.g., "-2min")
+    #[serde(default = "default_query_to")]
+    pub query_to: String,
+}
+
+impl Default for HealthQueryConfig {
+    fn default() -> Self {
+        Self {
+            query_from: default_query_from(),
+            query_to: default_query_to(),
+        }
+    }
+}
+
+fn default_query_from() -> String {
+    "-5min".to_string()
+}
+
+fn default_query_to() -> String {
+    "-2min".to_string()
+}
+
 #[cfg(test)]
 mod test {
     use crate::config;
 
+    use serial_test::serial;
     use std::env;
     use std::fs::{create_dir, File};
     use std::io::Write;
@@ -274,6 +307,7 @@ mod test {
 
     /// Test merging config with env vars
     #[test]
+    #[serial]
     fn test_merge_env() {
         // Create a file inside of `std::env::temp_dir()`.
         let mut config_file = Builder::new().suffix(".yaml").tempfile().unwrap();
@@ -283,7 +317,7 @@ mod test {
         env::set_var("MP_STATUS_DASHBOARD__SECRET", "val");
         let _config = config::Config::new(config_file.path().to_str().unwrap()).unwrap();
         assert_eq!(_config.status_dashboard.unwrap().secret.unwrap(), "val");
-        
+
         // Clean up to avoid affecting other tests
         env::remove_var("MP_STATUS_DASHBOARD__SECRET");
     }
@@ -359,13 +393,13 @@ mod test {
         health_metrics: {}
         ";
         let config = config::Config::from_config_str(minimal_config);
-        
+
         // Verify default server address
         assert_eq!("0.0.0.0", config.server.address);
-        
+
         // Verify default server port
         assert_eq!(3000, config.server.port);
-        
+
         // Verify default datasource timeout
         assert_eq!(10, config.datasource.timeout);
     }
@@ -385,25 +419,36 @@ mod test {
         health_metrics: {}
         ";
         let config = config::Config::from_config_str(config_str);
-        
+
         let socket_addr = config.get_socket_addr();
         assert_eq!("127.0.0.1:8080", socket_addr.to_string());
     }
 
     /// T047: Test config loading from multiple sources (file, conf.d, env vars)
-    /// Note: This test is effectively covered by test_merge_parts and test_merge_env,
+    /// Note: This test is effectively covered by test_merge_parts and test_merge_env
     /// but we add an explicit comprehensive test
     #[test]
+    #[serial]
     fn test_config_loading_from_multiple_sources() {
+        // Clear any lingering environment variables from other tests
+        // This is critical for test isolation when running all tests together
+        let mp_vars: Vec<String> = env::vars()
+            .filter(|(key, _)| key.starts_with("MP_"))
+            .map(|(key, _)| key)
+            .collect();
+        for key in &mp_vars {
+            env::remove_var(key);
+        }
+
         // Create temporary directory structure
         let dir = Builder::new().tempdir().unwrap();
         let main_config_path = dir.path().join("config.yaml");
         let mut main_config = File::create(&main_config_path).unwrap();
-        
+
         // Create conf.d directory
         let confd_path = dir.path().join("conf.d");
         create_dir(&confd_path).expect("Cannot create conf.d");
-        
+
         // Write main config with all required fields
         let main_config_content = "
         datasource:
@@ -421,9 +466,9 @@ mod test {
           - name: prod
         health_metrics: {}
         ";
-        main_config.write_all(main_config_content.as_bytes()).unwrap();
-        // Ensure file is flushed and closed before reading
-        drop(main_config);
+        main_config
+            .write_all(main_config_content.as_bytes())
+            .unwrap();
 
         // Write conf.d part
         let flags_config_content = "
@@ -436,34 +481,56 @@ mod test {
               - name: prod
         ";
         let mut flags_config = File::create(confd_path.join("flags.yaml")).unwrap();
-        flags_config.write_all(flags_config_content.as_bytes()).unwrap();
-        // Ensure file is flushed and closed before reading
-        drop(flags_config);
+        flags_config
+            .write_all(flags_config_content.as_bytes())
+            .unwrap();
 
-        // Set environment variables to ensure required fields are present
-        // This makes the test independent of any pre-existing env vars
-        env::set_var("MP_DATASOURCE__URL", "https://graphite.example.com");
+        // Set environment variable for server port (override main config)
         env::set_var("MP_SERVER__PORT", "8080");
-        
+
         // Load config from all sources
         let config = config::Config::new(main_config_path.to_str().unwrap()).unwrap();
-        
-        // Verify datasource config (env var ensures this is set)
+
+        // Verify main config loaded
         assert_eq!("https://graphite.example.com", config.datasource.url);
         assert_eq!(10, config.datasource.timeout);
-        
+
         // Verify conf.d part merged
         assert_eq!(1, config.flag_metrics.len());
         assert_eq!("test-metric", config.flag_metrics[0].name);
-        
+
         // Verify environment variable merged (overrides main config)
         assert_eq!(8080, config.server.port);
-        
-        // Clean up environment variables
-        env::remove_var("MP_DATASOURCE__URL");
+
+        // Clean up environment variable
         env::remove_var("MP_SERVER__PORT");
-        
+
         // Cleanup
         dir.close().unwrap();
     }
+
+    /// Generate JSON schema for configuration.
+    /// Run with: cargo test generate_config_schema -- --ignored
+    /// This test is ignored by default so it only runs when explicitly requested.
+    #[test]
+    #[ignore]
+    fn generate_config_schema() {
+        use schemars::schema_for;
+        use std::fs;
+        use std::path::Path;
+
+        let schema = schema_for!(config::Config);
+        let schema_json =
+            serde_json::to_string_pretty(&schema).expect("Failed to serialize schema");
+
+        let schemas_dir = Path::new("doc/schemas");
+        if !schemas_dir.exists() {
+            fs::create_dir_all(schemas_dir).expect("Failed to create doc/schemas directory");
+        }
+
+        let schema_path = schemas_dir.join("config-schema.json");
+        fs::write(&schema_path, &schema_json).expect("Failed to write config-schema.json");
+
+        println!("Generated JSON schema at: {}", schema_path.display());
+    }
 }
diff --git a/src/graphite.rs b/src/graphite.rs
index 2636d4c..ebad57b 100644
--- a/src/graphite.rs
+++ b/src/graphite.rs
@@ -92,14 +92,14 @@ where
 }
 
 pub fn get_graphite_routes() -> Router<AppState> {
-    return Router::new()
+    Router::new()
         .route("/functions", get(handler_functions))
         .route(
             "/metrics/find",
             get(handler_metrics_find_get).post(handler_metrics_find_post),
         )
         .route("/render", get(handler_render).post(handler_render))
-        .route("/tags/autoComplete/tags", get(handler_tags));
+        .route("/tags/autoComplete/tags", get(handler_tags))
 }
 
 /// Handler for graphite list supported functions API
@@ -206,7 +206,7 @@ pub fn find_metrics(find_request: MetricsQuery, state: AppState) -> Vec<Metric>
         }
         tracing::debug!("Elements {:?}", target_parts);
     }
-    return metrics;
+    metrics
 }
 
 /// POST Handler for graphite find metrics API
@@ -217,13 +217,13 @@ pub async fn handler_metrics_find_post(
 ) -> impl IntoResponse {
     tracing::debug!("Processing find query={:?}", query);
     let metrics: Vec<Metric> = find_metrics(query, state);
-    return (
+    (
         StatusCode::OK,
         Json(json!(metrics
             .into_iter()
             .sorted_by(|a, b| Ord::cmp(&a.text, &b.text))
             .collect::<Vec<Metric>>())),
-    );
+    )
 }
 
 /// GET Handler for graphite find metrics API
@@ -234,13 +234,13 @@ pub async fn handler_metrics_find_get(
 ) -> impl IntoResponse {
     tracing::debug!("Processing find query={:?}", query);
     let metrics: Vec<Metric> = find_metrics(query, state);
-    return (
+    (
         StatusCode::OK,
         Json(json!(metrics
             .into_iter()
             .sorted_by(|a, b| Ord::cmp(&a.text, &b.text))
             .collect::<Vec<Metric>>())),
-    );
+    )
 }
 
 /// Handler for graphite render API
@@ -286,18 +286,15 @@ pub async fn handler_render(
                         }
                     }
                 } else if let Some(metric) = state.flag_metrics.get(&metric_name) {
-                    match metric.get(environment) {
-                        Some(m) => {
-                            graphite_targets.insert(metric_name.clone(), m.query.clone());
-                        }
-                        _ => {}
-                    };
+                    if let Some(m) = metric.get(environment) {
+                        graphite_targets.insert(metric_name.clone(), m.query.clone());
+                    }
                 }
                 tracing::debug!("Requesting Graphite {:?}", graphite_targets);
 
                 match get_graphite_data(
                     &state.req_client,
-                    &state.config.datasource.url.as_str(),
+                    state.config.datasource.url.as_str(),
                     &graphite_targets,
                     None,
                     from,
@@ -366,7 +363,7 @@ pub async fn handler_render(
                     return (
                         StatusCode::OK,
                         Json(
-                            json!([{"target": target_parts[2], "datapoints": service_health_data.iter().map(|x| (Some(x.1 as f32), x.0)).collect::<Vec<(Option<f32>, u32)>>()}]),
+                            json!([{"target": target_parts[2], "datapoints": service_health_data.iter().map(|x| (Some(x.weight as f32), x.timestamp)).collect::<Vec<(Option<f32>, u32)>>()}]),
                         ),
                     );
                 }
@@ -386,6 +383,7 @@ fn alias_graphite_query(query: &str, alias: &str) -> String {
 }
 
 /// Fetch required data from Graphite
+#[allow(clippy::too_many_arguments)]
 pub async fn get_graphite_data(
     client: &reqwest::Client,
     url: &str,
@@ -428,18 +426,18 @@ pub async fn get_graphite_data(
         Ok(rsp) => {
             if rsp.status().is_client_error() {
                 tracing::error!("Error: {:?}", rsp.text().await);
-                return Err(CloudMonError::GraphiteError);
+                Err(CloudMonError::GraphiteError)
             } else {
                 tracing::trace!("Status: {}", rsp.status());
                 tracing::trace!("Headers:\n{:#?}", rsp.headers());
                 match rsp.json().await {
-                    Ok(dt) => return Ok(dt),
-                    Err(_) => return Err(CloudMonError::GraphiteError),
+                    Ok(dt) => Ok(dt),
+                    Err(_) => Err(CloudMonError::GraphiteError),
                 }
             }
         }
-        Err(_) => return Err(CloudMonError::GraphiteError),
-    };
+        Err(_) => Err(CloudMonError::GraphiteError),
+    }
 }
 ///
 /// Handler for graphite tags API
@@ -667,26 +665,30 @@ mod test {
     async fn test_render_flag_target() {
         // Create mock Graphite server
         let mut server = mockito::Server::new();
-        
+
         // Mock the /render endpoint - returns raw metric data
         let _mock = server
             .mock("GET", "/render")
             .match_query(Matcher::Any)
             .with_status(200)
             .with_header("content-type", "application/json")
-            .with_body(json!([
-                {
-                    "target": "webapp.cpu-usage",
-                    "datapoints": [
-                        [85.0, 1609459200],  // > 80, should become 1
-                        [92.0, 1609459260],  // > 80, should become 1
-                        [78.0, 1609459320]   // <= 80, should become 0
-                    ]
-                }
-            ]).to_string())
+            .with_body(
+                json!([
+                    {
+                        "target": "webapp.cpu-usage",
+                        "datapoints": [
+                            [85.0, 1609459200],  // > 80, should become 1
+                            [92.0, 1609459260],  // > 80, should become 1
+                            [78.0, 1609459320]   // <= 80, should become 0
+                        ]
+                    }
+                ])
+                .to_string(),
+            )
             .create();
 
-        let config_str = format!("
+        let config_str = format!(
+            "
         datasource:
           url: '{}'
         server:
@@ -706,8 +708,10 @@ mod test {
             environments:
               - name: prod
         health_metrics: {{}}
-        ", server.url());
-        
+        ",
+            server.url()
+        );
+
         let config = config::Config::from_config_str(&config_str);
         let mut state = types::AppState::new(config);
         state.process_config();
@@ -721,58 +725,66 @@ mod test {
 
         let response = app.ready().await.unwrap().call(request).await.unwrap();
         assert_eq!(response.status(), StatusCode::OK);
-        
+
         let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
         let body: Value = serde_json::from_slice(&body).unwrap();
-        
+
         // Should return array with datapoints
         assert!(body.is_array());
         let arr = body.as_array().unwrap();
         assert_eq!(arr.len(), 1, "Should return one metric");
-        
+
         // Verify structure contains target and datapoints
         let first = &arr[0];
         assert!(first.get("target").is_some());
         assert!(first.get("datapoints").is_some());
-        
+
         // Datapoints should contain boolean values (0 or 1) after transformation
         let datapoints = first["datapoints"].as_array().unwrap();
         assert_eq!(datapoints.len(), 3, "Should have 3 datapoints");
-        
+
         for dp in datapoints {
             let point_arr = dp.as_array().unwrap();
             let value = point_arr[0].as_f64();
             if let Some(v) = value {
-                assert!(v == 0.0 || v == 1.0, "Flag values should be 0 or 1, got {}", v);
+                assert!(
+                    v == 0.0 || v == 1.0,
+                    "Flag values should be 0 or 1, got {}",
+                    v
+                );
             }
         }
     }
-    
+
     /// T054: Test /render with health target returns health scores
     /// Testing with mocked Graphite to verify health score calculation
     #[tokio::test]
     async fn test_render_health_target() {
         // Create mock Graphite server
         let mut server = mockito::Server::new();
-        
+
         // Mock the /render endpoint - returns raw metric data
         let _mock = server
             .mock("GET", "/render")
             .match_query(Matcher::Any)
             .with_status(200)
             .with_header("content-type", "application/json")
-            .with_body(json!([
-                {
-                    "target": "webapp.cpu-usage",
-                    "datapoints": [
-                        [85.0, 1609459200],  // > 80, flag=true, weight=2
-                        [90.0, 1609459260]   // > 80, flag=true, weight=2
-                    ]
-                }
-            ]).to_string())
+            .with_body(
+                json!([
+                    {
+                        "target": "webapp.cpu-usage",
+                        "datapoints": [
+                            [85.0, 1609459200],  // > 80, flag=true, weight=2
+                            [90.0, 1609459260]   // > 80, flag=true, weight=2
+                        ]
+                    }
+                ])
+                .to_string(),
+            )
             .create();
 
-        let config_str = format!("
+        let config_str = format!(
+            "
         datasource:
           url: '{}'
         server:
@@ -800,8 +812,10 @@ mod test {
             expressions:
               - expression: 'webapp.cpu_usage'
                 weight: 2
-        ", server.url());
-        
+        ",
+            server.url()
+        );
+
         let config = config::Config::from_config_str(&config_str);
         let mut state = types::AppState::new(config);
         state.process_config();
@@ -815,25 +829,25 @@ mod test {
 
         let response = app.ready().await.unwrap().call(request).await.unwrap();
         assert_eq!(response.status(), StatusCode::OK);
-        
+
         let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
         let body: Value = serde_json::from_slice(&body).unwrap();
-        
+
         // Should return array with datapoints
         assert!(body.is_array());
         let arr = body.as_array().unwrap();
         assert_eq!(arr.len(), 1, "Should return one metric");
-        
+
         // Verify structure contains target and datapoints
         let first = &arr[0];
         assert!(first.get("target").is_some());
         assert_eq!(first["target"], "webapp");
         assert!(first.get("datapoints").is_some());
-        
+
         // Health scores should be numeric weights (0, 1, 2, etc.)
         let datapoints = first["datapoints"].as_array().unwrap();
         assert!(datapoints.len() > 0, "Should have datapoints");
-        
+
         for dp in datapoints {
             let point_arr = dp.as_array().unwrap();
             let value = point_arr[0].as_f64();
@@ -870,7 +884,7 @@ mod test {
 
         let response = app.ready().await.unwrap().call(request).await.unwrap();
         assert_eq!(response.status(), StatusCode::OK);
-        
+
         let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
         let body: Value = serde_json::from_slice(&body).unwrap();
         assert_eq!(body, json!([]));
@@ -903,7 +917,7 @@ mod test {
 
         let response = app.ready().await.unwrap().call(request).await.unwrap();
         assert_eq!(response.status(), StatusCode::OK);
-        
+
         let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
         let body: Value = serde_json::from_slice(&body).unwrap();
         assert_eq!(body, json!({}));
@@ -933,7 +947,7 @@ mod test {
 
         let response = app.ready().await.unwrap().call(request).await.unwrap();
         assert_eq!(response.status(), StatusCode::OK);
-        
+
         let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
         let body: Value = serde_json::from_slice(&body).unwrap();
         assert_eq!(body, json!([]));
@@ -943,7 +957,7 @@ mod test {
     #[test]
     fn test_graphite_4xx_error() {
         let mut server = mockito::Server::new();
-        
+
         let _mock = server
             .mock("GET", "/render")
             .match_query(Matcher::Any)
@@ -953,10 +967,10 @@ mod test {
 
         let timeout = Duration::from_secs(1);
         let req_client = ClientBuilder::new().timeout(timeout).build().unwrap();
-        
+
         let mut targets: HashMap<String, String> = HashMap::new();
         targets.insert("test".to_string(), "query".to_string());
-        
+
         let result = aw!(graphite::get_graphite_data(
             &req_client,
             &server.url(),
@@ -967,7 +981,7 @@ mod test {
             Some("now".to_string()),
             10,
         ));
-        
+
         assert!(result.is_err(), "Should return error for 404 response");
     }
 
@@ -975,7 +989,7 @@ mod test {
     #[test]
     fn test_graphite_5xx_error() {
         let mut server = mockito::Server::new();
-        
+
         let _mock = server
             .mock("GET", "/render")
             .match_query(Matcher::Any)
@@ -985,10 +999,10 @@ mod test {
 
         let timeout = Duration::from_secs(1);
         let req_client = ClientBuilder::new().timeout(timeout).build().unwrap();
-        
+
         let mut targets: HashMap<String, String> = HashMap::new();
         targets.insert("test".to_string(), "query".to_string());
-        
+
         let result = aw!(graphite::get_graphite_data(
             &req_client,
             &server.url(),
@@ -999,7 +1013,7 @@ mod test {
             Some("now".to_string()),
             10,
         ));
-        
+
         assert!(result.is_err(), "Should return error for 500 response");
     }
 
@@ -1007,7 +1021,7 @@ mod test {
     #[test]
     fn test_graphite_malformed_json() {
         let mut server = mockito::Server::new();
-        
+
         let _mock = server
             .mock("GET", "/render")
             .match_query(Matcher::Any)
@@ -1018,10 +1032,10 @@ mod test {
 
         let timeout = Duration::from_secs(1);
         let req_client = ClientBuilder::new().timeout(timeout).build().unwrap();
-        
+
         let mut targets: HashMap<String, String> = HashMap::new();
         targets.insert("test".to_string(), "query".to_string());
-        
+
         let result = aw!(graphite::get_graphite_data(
             &req_client,
             &server.url(),
@@ -1032,7 +1046,7 @@ mod test {
             Some("now".to_string()),
             10,
         ));
-        
+
         assert!(result.is_err(), "Should return error for malformed JSON");
     }
 
@@ -1042,10 +1056,10 @@ mod test {
         // Use a very short timeout to force timeout
         let timeout = Duration::from_millis(1);
         let req_client = ClientBuilder::new().timeout(timeout).build().unwrap();
-        
+
         let mut targets: HashMap<String, String> = HashMap::new();
         targets.insert("test".to_string(), "query".to_string());
-        
+
         // Use a non-routable IP to guarantee timeout
         let result = aw!(graphite::get_graphite_data(
             &req_client,
@@ -1057,7 +1071,7 @@ mod test {
             Some("now".to_string()),
             10,
         ));
-        
+
         assert!(result.is_err(), "Should return error for timeout");
     }
 
@@ -1065,29 +1079,32 @@ mod test {
     #[test]
     fn test_graphite_partial_response() {
         let mut server = mockito::Server::new();
-        
+
         // Return data for only some of the requested metrics
         let _mock = server
             .mock("GET", "/render")
             .match_query(Matcher::Any)
             .with_status(200)
             .with_header("content-type", "application/json")
-            .with_body(json!([
-                {
-                    "target": "metric1",
-                    "datapoints": [[10.0, 1609459200]]
-                }
-                // metric2 is missing from response
-            ]).to_string())
+            .with_body(
+                json!([
+                    {
+                        "target": "metric1",
+                        "datapoints": [[10.0, 1609459200]]
+                    }
+                    // metric2 is missing from response
+                ])
+                .to_string(),
+            )
             .create();
 
         let timeout = Duration::from_secs(1);
         let req_client = ClientBuilder::new().timeout(timeout).build().unwrap();
-        
+
         let mut targets: HashMap<String, String> = HashMap::new();
         targets.insert("metric1".to_string(), "query1".to_string());
         targets.insert("metric2".to_string(), "query2".to_string());
-        
+
         let result = aw!(graphite::get_graphite_data(
             &req_client,
             &server.url(),
@@ -1098,7 +1115,7 @@ mod test {
             Some("now".to_string()),
             10,
         ));
-        
+
         // Should successfully return data for available metrics
         assert!(result.is_ok(), "Should handle partial response gracefully");
         let data = result.unwrap();
@@ -1151,7 +1168,7 @@ mod test {
     #[tokio::test]
     async fn test_render_post() {
         let mut server = mockito::Server::new();
-        
+
         let _mock = server
             .mock("GET", "/render")
             .match_query(Matcher::Any)
@@ -1160,7 +1177,8 @@ mod test {
             .with_body(json!([]).to_string())
             .create();
 
-        let config_str = format!("
+        let config_str = format!(
+            "
         datasource:
           url: '{}'
         server:
@@ -1169,8 +1187,10 @@ mod test {
           - name: prod
         flag_metrics: []
         health_metrics: {{}}
-        ", server.url());
-        
+        ",
+            server.url()
+        );
+
         let config = config::Config::from_config_str(&config_str);
         let mut state = types::AppState::new(config);
         state.process_config();
@@ -1181,7 +1201,9 @@ mod test {
             .method("POST")
             .uri("/render")
             .header("content-type", "application/json")
-            .body(Body::from(r#"{"target": "invalid.target", "maxDataPoints": 10}"#))
+            .body(Body::from(
+                r#"{"target": "invalid.target", "maxDataPoints": 10}"#,
+            ))
             .unwrap();
 
         let response = app.ready().await.unwrap().call(request).await.unwrap();
@@ -1238,22 +1260,26 @@ mod test {
     #[tokio::test]
     async fn test_render_with_unknown_metric_in_response() {
         let mut server = mockito::Server::new();
-        
+
         // Mock returns a metric that doesn't exist in our config
         let _mock = server
             .mock("GET", "/render")
             .match_query(Matcher::Any)
             .with_status(200)
             .with_header("content-type", "application/json")
-            .with_body(json!([
-                {
-                    "target": "unknown.metric",
-                    "datapoints": [[85.0, 1609459200]]
-                }
-            ]).to_string())
+            .with_body(
+                json!([
+                    {
+                        "target": "unknown.metric",
+                        "datapoints": [[85.0, 1609459200]]
+                    }
+                ])
+                .to_string(),
+            )
             .create();
 
-        let config_str = format!("
+        let config_str = format!(
+            "
         datasource:
           url: '{}'
         server:
@@ -1273,8 +1299,10 @@ mod test {
             environments:
               - name: prod
         health_metrics: {{}}
-        ", server.url());
-        
+        ",
+            server.url()
+        );
+
         let config = config::Config::from_config_str(&config_str);
         let mut state = types::AppState::new(config);
         state.process_config();
@@ -1293,21 +1321,25 @@ mod test {
     #[tokio::test]
     async fn test_render_wildcard_metric() {
         let mut server = mockito::Server::new();
-        
+
         let _mock = server
             .mock("GET", "/render")
             .match_query(Matcher::Any)
             .with_status(200)
             .with_header("content-type", "application/json")
-            .with_body(json!([
-                {
-                    "target": "webapp.cpu-usage",
-                    "datapoints": [[85.0, 1609459200]]
-                }
-            ]).to_string())
+            .with_body(
+                json!([
+                    {
+                        "target": "webapp.cpu-usage",
+                        "datapoints": [[85.0, 1609459200]]
+                    }
+                ])
+                .to_string(),
+            )
             .create();
 
-        let config_str = format!("
+        let config_str = format!(
+            "
         datasource:
           url: '{}'
         server:
@@ -1327,8 +1359,10 @@ mod test {
             environments:
               - name: prod
         health_metrics: {{}}
-        ", server.url());
-        
+        ",
+            server.url()
+        );
+
         let config = config::Config::from_config_str(&config_str);
         let mut state = types::AppState::new(config);
         state.process_config();
@@ -1348,7 +1382,7 @@ mod test {
     #[tokio::test]
     async fn test_render_graphite_error() {
         let mut server = mockito::Server::new();
-        
+
         // Return an error status
         let _mock = server
             .mock("GET", "/render")
@@ -1357,7 +1391,8 @@ mod test {
             .with_body("Internal Server Error")
             .create();
 
-        let config_str = format!("
+        let config_str = format!(
+            "
         datasource:
           url: '{}'
         server:
@@ -1377,8 +1412,10 @@ mod test {
             environments:
               - name: prod
         health_metrics: {{}}
-        ", server.url());
-        
+        ",
+            server.url()
+        );
+
         let config = config::Config::from_config_str(&config_str);
         let mut state = types::AppState::new(config);
         state.process_config();
diff --git a/src/lib.rs b/src/lib.rs
index 98dd726..a5f2c2c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -6,4 +6,5 @@ pub mod api;
 pub mod common;
 pub mod config;
 pub mod graphite;
+pub mod sd;
 pub mod types;
diff --git a/src/sd.rs b/src/sd.rs
new file mode 100644
index 0000000..bfae872
--- /dev/null
+++ b/src/sd.rs
@@ -0,0 +1,179 @@
+//! Status Dashboard integration module
+//!
+//! This module contains all functionality for integrating with the Status Dashboard API,
+//! including component management, incident creation, cache operations, and authentication.
+
+use anyhow;
+use hmac::{Hmac, Mac};
+use jwt::SignWithKey;
+use reqwest::header::HeaderMap;
+use serde::{Deserialize, Serialize};
+use sha2::Sha256;
+use std::collections::{BTreeMap, HashMap};
+
+/// Component attribute (key-value pair) for identifying components
+#[derive(Clone, Deserialize, Serialize, Debug, PartialEq, Eq, Hash, Ord, PartialOrd)]
+pub struct ComponentAttribute {
+    pub name: String,
+    pub value: String,
+}
+
+/// Component definition from configuration
+#[derive(Clone, Deserialize, Serialize, Debug)]
+pub struct Component {
+    pub name: String,
+    pub attributes: Vec<ComponentAttribute>,
+}
+
+/// Component status for V1 API (legacy, deprecated - use V2 IncidentData instead)
+#[derive(Clone, Deserialize, Serialize, Debug)]
+pub struct ComponentStatus {
+    pub name: String,
+    pub impact: u8,
+    pub attributes: Vec<ComponentAttribute>,
+}
+
+/// Component data from Status Dashboard API V2 GET /v2/components response
+#[derive(Clone, Deserialize, Serialize, Debug)]
+pub struct StatusDashboardComponent {
+    pub id: u32,
+    pub name: String,
+    #[serde(default)]
+    pub attributes: Vec<ComponentAttribute>,
+}
+
+/// Incident data for Status Dashboard API V2 POST request
+#[derive(Clone, Deserialize, Serialize, Debug)]
+pub struct IncidentData {
+    pub title: String,
+    pub description: String,
+    pub impact: u8,
+    pub components: Vec<u32>,
+    pub start_date: String,
+    pub system: bool,
+    #[serde(rename = "type")]
+    pub incident_type: String,
+}
+
+/// Component ID cache: maps (component_name, sorted_attributes) to component_id
+pub type ComponentCache = HashMap<(String, Vec<ComponentAttribute>), u32>;
+
+/// Generate HMAC-JWT authorization headers for Status Dashboard API
+///
+/// Creates a Bearer token using HMAC-SHA256 signing with the provided secret.
+/// Returns empty HeaderMap if no secret is provided (for optional auth environments).
+///
+/// # Arguments
+/// * `secret` - Optional HMAC secret for JWT signing
+///
+/// # Returns
+/// HeaderMap with Authorization header if secret provided, empty otherwise
+pub fn build_auth_headers(secret: Option<&str>) -> HeaderMap {
+    let mut headers = HeaderMap::new();
+    if let Some(secret) = secret {
+        let key: Hmac<Sha256> = Hmac::new_from_slice(secret.as_bytes()).unwrap();
+        let mut claims = BTreeMap::new();
+        claims.insert("stackmon", "dummy");
+        let token_str = claims.sign_with_key(&key).unwrap();
+        let bearer = format!("Bearer {}", token_str);
+        headers.insert(reqwest::header::AUTHORIZATION, bearer.parse().unwrap());
+    }
+    headers
+}
+
+/// Fetch all components from Status Dashboard API V2
+pub async fn fetch_components(
+    client: &reqwest::Client,
+    base_url: &str,
+    headers: &HeaderMap,
+) -> anyhow::Result<Vec<StatusDashboardComponent>> {
+    let url = format!("{}/v2/components", base_url);
+    let response = client.get(&url).headers(headers.clone()).send().await?;
+
+    if !response.status().is_success() {
+        anyhow::bail!(
+            "Failed to fetch components: status={}, body={:?}",
+            response.status(),
+            response.text().await
+        );
+    }
+
+    let components: Vec<StatusDashboardComponent> = response.json().await?;
+    Ok(components)
+}
+
+/// Build component ID cache from fetched components
+pub fn build_component_id_cache(components: Vec<StatusDashboardComponent>) -> ComponentCache {
+    components
+        .into_iter()
+        .map(|c| {
+            let mut attrs = c.attributes;
+            attrs.sort(); // Ensure deterministic key
+            ((c.name, attrs), c.id)
+        })
+        .collect()
+}
+
+/// Find component ID in cache with subset attribute matching
+/// Returns the component ID if found, None otherwise
+pub fn find_component_id(cache: &ComponentCache, target: &Component) -> Option<u32> {
+    cache
+        .iter()
+        .filter(|((name, _attrs), _id)| name == &target.name)
+        .find(|((_name, cache_attrs), _id)| {
+            // Config attrs must be subset of cache attrs
+            target.attributes.iter().all(|target_attr| {
+                cache_attrs.iter().any(|cache_attr| {
+                    cache_attr.name == target_attr.name && cache_attr.value == target_attr.value
+                })
+            })
+        })
+        .map(|((_name, _attrs), id)| *id)
+}
+
+/// Build incident data structure for V2 API
+/// timestamp: metric timestamp in seconds since epoch
+pub fn build_incident_data(component_id: u32, impact: u8, timestamp: i64) -> IncidentData {
+    // Convert timestamp to RFC3339 and subtract 1 second per FR-011
+    let start_date = chrono::DateTime::from_timestamp(timestamp - 1, 0)
+        .expect("Invalid timestamp")
+        .to_rfc3339();
+
+    IncidentData {
+        title: "System incident from monitoring system".to_string(),
+        description:
+            "System-wide incident affecting one or multiple components. Created automatically."
+                .to_string(),
+        impact,
+        components: vec![component_id],
+        start_date,
+        system: true,
+        incident_type: "incident".to_string(),
+    }
+}
+
+/// Create incident via Status Dashboard API V2
+pub async fn create_incident(
+    client: &reqwest::Client,
+    base_url: &str,
+    headers: &HeaderMap,
+    incident_data: &IncidentData,
+) -> anyhow::Result<()> {
+    let url = format!("{}/v2/events", base_url);
+    let response = client
+        .post(&url)
+        .headers(headers.clone())
+        .json(incident_data)
+        .send()
+        .await?;
+
+    if !response.status().is_success() {
+        anyhow::bail!(
+            "Failed to create incident: status={}, body={:?}",
+            response.status(),
+            response.text().await
+        );
+    }
+
+    Ok(())
+}
diff --git a/src/types.rs b/src/types.rs
index df06bf0..a185b2e 100644
--- a/src/types.rs
+++ b/src/types.rs
@@ -4,6 +4,7 @@
 use crate::config::Config;
 use new_string_template::template::Template;
 use regex::Regex;
+use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::collections::HashSet;
 use std::collections::{BTreeMap, HashMap};
@@ -12,7 +13,7 @@ use std::time::Duration;
 
 use reqwest::ClientBuilder;
 
-#[derive(Clone, Debug, Deserialize, PartialEq)]
+#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq)]
 #[serde(rename_all = "lowercase")]
 pub enum CmpType {
     Lt,
@@ -20,7 +21,7 @@ pub enum CmpType {
     Eq,
 }
 
-#[derive(Clone, Debug, Deserialize)]
+#[derive(Clone, Debug, Deserialize, JsonSchema)]
 pub struct BinaryMetricRawDef {
     pub query: String,
     pub op: CmpType,
@@ -37,7 +38,7 @@ impl Default for BinaryMetricRawDef {
     }
 }
 
-#[derive(Clone, Debug, Deserialize)]
+#[derive(Clone, Debug, Deserialize, JsonSchema)]
 pub struct BinaryMetricDef {
     pub query: Option<String>,
     pub op: Option<CmpType>,
@@ -45,19 +46,19 @@ pub struct BinaryMetricDef {
     pub template: Option<MetricTemplateRef>,
 }
 
-#[derive(Clone, Debug, Deserialize)]
+#[derive(Clone, Debug, Deserialize, JsonSchema)]
 pub struct MetricTemplateRef {
     pub name: String,
     pub vars: Option<HashMap<String, String>>,
 }
 
-#[derive(Clone, Debug, Deserialize)]
+#[derive(Clone, Debug, Deserialize, JsonSchema)]
 pub struct EnvironmentDef {
     pub name: String,
     pub attributes: Option<HashMap<String, String>>,
 }
 
-#[derive(Clone, Debug, Deserialize)]
+#[derive(Clone, Debug, Deserialize, JsonSchema)]
 pub struct FlagMetric {
     pub query: String,
     pub op: CmpType,
@@ -74,13 +75,13 @@ impl Default for FlagMetric {
     }
 }
 
-#[derive(Clone, Debug, Deserialize)]
+#[derive(Clone, Debug, Deserialize, JsonSchema)]
 pub struct MetricExpressionDef {
     pub expression: String,
     pub weight: i32,
 }
 
-#[derive(Clone, Debug, Deserialize)]
+#[derive(Clone, Debug, Deserialize, JsonSchema)]
 pub struct FlagMetricDef {
     pub name: String,
     pub service: String,
@@ -88,13 +89,13 @@ pub struct FlagMetricDef {
     pub environments: Vec<MetricEnvironmentDef>,
 }
 
-#[derive(Clone, Debug, Deserialize)]
+#[derive(Clone, Debug, Deserialize, JsonSchema)]
 pub struct MetricEnvironmentDef {
     pub name: String,
     pub threshold: Option<f32>,
 }
 
-#[derive(Clone, Debug, Deserialize)]
+#[derive(Clone, Debug, Deserialize, JsonSchema)]
 pub struct ServiceHealthDef {
     pub service: String,
     pub component_name: Option<String>,
@@ -110,8 +111,37 @@ pub struct MetricData {
     #[serde(rename(serialize = "datapoints"))]
     pub points: MetricPoints,
 }
-/// List of the service health values (ts, data)
-pub type ServiceHealthData = Vec<(u32, u8)>;
+
+/// Health data point with diagnostic information
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct ServiceHealthDataPoint {
+    /// Timestamp
+    pub timestamp: u32,
+    /// Health weight/impact (0=healthy, 1=degraded, 2=outage)
+    pub weight: u8,
+    /// Individual metric states (metric_name -> true/false)
+    pub metric_states: HashMap<String, bool>,
+    /// The expression that matched (if any)
+    pub matched_expression: Option<String>,
+    /// Details of triggered metrics (only metrics with state=true)
+    pub triggered_metric_details: Vec<MetricDetail>,
+}
+
+/// Details of a triggered metric including its template configuration
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct MetricDetail {
+    /// Metric name (e.g., "as.api_down")
+    pub name: String,
+    /// The Graphite query used
+    pub query: String,
+    /// Comparison operator (lt, gt, eq)
+    pub op: String,
+    /// Threshold value
+    pub threshold: f32,
+}
+
+/// List of the service health values with diagnostics
+pub type ServiceHealthData = Vec<ServiceHealthDataPoint>;
 
 pub enum CloudMonError {
     ServiceNotSupported,
@@ -158,7 +188,7 @@ impl AppState {
         let timeout = Duration::from_secs(config.datasource.timeout as u64);
 
         Self {
-            config: config,
+            config,
             metric_templates: HashMap::new(),
             flag_metrics: HashMap::new(),
             req_client: ClientBuilder::new().timeout(timeout).build().unwrap(),
@@ -182,16 +212,17 @@ impl AppState {
                 let tmpl = self.metric_templates.get(&tmpl_ref.name).unwrap();
                 let tmpl_query = Template::new(tmpl.query.clone()).with_regex(&custom_regex);
                 for env in metric_def.environments.iter() {
-                    let mut raw = FlagMetric::default();
-                    raw.op = tmpl.op.clone();
-                    raw.threshold = match env.threshold {
-                        Some(x) => x,
-                        None => tmpl.threshold.clone(),
+                    let threshold = env.threshold.unwrap_or(tmpl.threshold);
+                    let raw = FlagMetric {
+                        query: String::new(), // Will be set below
+                        op: tmpl.op.clone(),
+                        threshold,
                     };
                     let vars: HashMap<&str, &str> = HashMap::from([
                         ("service", metric_def.service.as_str()),
                         ("environment", env.name.as_str()),
                     ]);
+                    let mut raw = raw;
                     raw.query = tmpl_query.render(&vars).unwrap();
                     if let Some(x) = self.flag_metrics.get_mut(&metric_name) {
                         x.insert(env.name.clone(), raw.clone());
@@ -227,7 +258,7 @@ impl AppState {
                     expression = expression.replace(k, v);
                 }
                 int_metric.expressions.push(MetricExpressionDef {
-                    expression: expression,
+                    expression,
                     weight: expr.weight,
                 });
             }
@@ -394,14 +425,29 @@ mod test {
         // Verify metric exists for all three environments
         let metric_key = "api.error-count";
         assert!(state.flag_metrics.contains_key(metric_key));
-        
-        let dev_metric = state.flag_metrics.get(metric_key).unwrap().get("dev").unwrap();
+
+        let dev_metric = state
+            .flag_metrics
+            .get(metric_key)
+            .unwrap()
+            .get("dev")
+            .unwrap();
         assert_eq!("dev.api.errors", dev_metric.query);
-        
-        let staging_metric = state.flag_metrics.get(metric_key).unwrap().get("staging").unwrap();
+
+        let staging_metric = state
+            .flag_metrics
+            .get(metric_key)
+            .unwrap()
+            .get("staging")
+            .unwrap();
         assert_eq!("staging.api.errors", staging_metric.query);
-        
-        let prod_metric = state.flag_metrics.get(metric_key).unwrap().get("production").unwrap();
+
+        let prod_metric = state
+            .flag_metrics
+            .get(metric_key)
+            .unwrap()
+            .get("production")
+            .unwrap();
         assert_eq!("production.api.errors", prod_metric.query);
     }
 
@@ -445,7 +491,7 @@ mod test {
             .get("dev")
             .unwrap();
         assert_eq!(5000.0, dev_metric.threshold);
-        
+
         // Verify production has override threshold of 500
         let prod_metric = state
             .flag_metrics
@@ -578,53 +624,62 @@ mod test {
     }
 }
 
-    /// Additional coverage test: Test CloudMonError Display implementation
-    #[test]
-    fn test_error_display() {
-        assert_eq!(
-            format!("{}", CloudMonError::ServiceNotSupported),
-            "Requested service not supported"
-        );
-        assert_eq!(
-            format!("{}", CloudMonError::EnvNotSupported),
-            "Environment for service not supported"
-        );
-        assert_eq!(
-            format!("{}", CloudMonError::ExpressionError),
-            "Internal Expression evaluation error"
-        );
-        assert_eq!(
-            format!("{}", CloudMonError::GraphiteError),
-            "Graphite error"
-        );
-    }
+/// Additional coverage test: Test CloudMonError Display implementation
+#[test]
+fn test_error_display() {
+    assert_eq!(
+        format!("{}", CloudMonError::ServiceNotSupported),
+        "Requested service not supported"
+    );
+    assert_eq!(
+        format!("{}", CloudMonError::EnvNotSupported),
+        "Environment for service not supported"
+    );
+    assert_eq!(
+        format!("{}", CloudMonError::ExpressionError),
+        "Internal Expression evaluation error"
+    );
+    assert_eq!(
+        format!("{}", CloudMonError::GraphiteError),
+        "Graphite error"
+    );
+}
 
-    /// Additional coverage test: Test CloudMonError Debug implementation
-    #[test]
-    fn test_error_debug() {
-        assert_eq!(
-            format!("{:?}", CloudMonError::ServiceNotSupported),
-            "Requested service not supported"
-        );
-        assert_eq!(
-            format!("{:?}", CloudMonError::EnvNotSupported),
-            "Environment for service not supported"
-        );
-        assert_eq!(
-            format!("{:?}", CloudMonError::ExpressionError),
-            "Internal Expression evaluation error"
-        );
-        assert_eq!(
-            format!("{:?}", CloudMonError::GraphiteError),
-            "Graphite error"
-        );
-    }
+/// Additional coverage test: Test CloudMonError Debug implementation
+#[test]
+fn test_error_debug() {
+    assert_eq!(
+        format!("{:?}", CloudMonError::ServiceNotSupported),
+        "Requested service not supported"
+    );
+    assert_eq!(
+        format!("{:?}", CloudMonError::EnvNotSupported),
+        "Environment for service not supported"
+    );
+    assert_eq!(
+        format!("{:?}", CloudMonError::ExpressionError),
+        "Internal Expression evaluation error"
+    );
+    assert_eq!(
+        format!("{:?}", CloudMonError::GraphiteError),
+        "Graphite error"
+    );
+}
 
-    /// Additional coverage test: Test BinaryMetricRawDef Default
-    #[test]
-    fn test_binary_metric_raw_def_default() {
-        let default = BinaryMetricRawDef::default();
-        assert_eq!(default.query, String::new());
-        assert_eq!(default.op, CmpType::Lt);
-        assert_eq!(default.threshold, 0.0);
-    }
+/// Additional coverage test: Test BinaryMetricRawDef Default
+#[test]
+fn test_binary_metric_raw_def_default() {
+    let default = BinaryMetricRawDef::default();
+    assert_eq!(default.query, String::new());
+    assert_eq!(default.op, CmpType::Lt);
+    assert_eq!(default.threshold, 0.0);
+}
+
+/// Additional coverage test: Test FlagMetric Default implementation
+#[test]
+fn test_flag_metric_default() {
+    let default = FlagMetric::default();
+    assert_eq!(default.query, String::new());
+    assert!(matches!(default.op, CmpType::Lt));
+    assert_eq!(default.threshold, 0.0);
+}
diff --git a/tests/docker/carbonapi.yml b/tests/docker/carbonapi.yml
new file mode 100644
index 0000000..c9d1109
--- /dev/null
+++ b/tests/docker/carbonapi.yml
@@ -0,0 +1,36 @@
+# CarbonAPI configuration for testing
+listen: ":8080"
+prefix: ""
+notFoundStatusCode: 404
+headersToPass: []
+headersToLog: []
+
+upstreams:
+  backends:
+    - "http://go-carbon:7002"
+
+  timeouts:
+    find: "2s"
+    render: "10s"
+    connect: "2s"
+
+expireDelaySec: 600
+maxBatchSize: 100
+
+concurrency:
+  maxProcs: 0
+  maxRenderRequest: 10
+  maxBatchRenderRequest: 10
+
+cache:
+  type: "mem"
+  size_mb: 0
+  defaultTimeoutSec: 60
+
+logger:
+  - logger: ""
+    file: "stdout"
+    level: "info"
+    encoding: "console"
+    encodingTime: "iso8601"
+    encodingDuration: "seconds"
diff --git a/tests/docker/docker-compose.yml b/tests/docker/docker-compose.yml
new file mode 100644
index 0000000..1cfca2b
--- /dev/null
+++ b/tests/docker/docker-compose.yml
@@ -0,0 +1,38 @@
+services:
+  # go-carbon for metrics storage (Carbon replacement)
+  go-carbon:
+    image: ghcr.io/go-graphite/go-carbon:latest
+    container_name: metrics-processor-go-carbon
+    user: "0:0"  # Run as root to ensure write permissions
+    ports:
+      - "2003:2003"      # Carbon plaintext
+      - "2004:2004"      # Carbon pickle
+      - "7002:7002"      # Carbonserver (for carbonapi)
+    volumes:
+      - whisper_data:/data/graphite/whisper
+      - ./go-carbon.conf:/etc/go-carbon/go-carbon.conf:ro
+    healthcheck:
+      test: ["CMD", "nc", "-z", "localhost", "2003"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+
+  # CarbonAPI for Graphite-compatible API
+  carbonapi:
+    image: quay.io/opentelekomcloud/carbonapi:v0.16.1
+    container_name: metrics-processor-carbonapi
+    ports:
+      - "8080:8080"      # Graphite API
+    volumes:
+      - ./carbonapi.yml:/etc/carbonapi.yml:ro
+    depends_on:
+      go-carbon:
+        condition: service_healthy
+    healthcheck:
+      test: ["CMD", "wget", "--spider", "-q", "http://localhost:8080/render?format=json"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+
+volumes:
+  whisper_data:
diff --git a/tests/docker/go-carbon.conf b/tests/docker/go-carbon.conf
new file mode 100644
index 0000000..456eddb
--- /dev/null
+++ b/tests/docker/go-carbon.conf
@@ -0,0 +1,57 @@
+# go-carbon configuration for testing
+[common]
+user = ""
+graph-prefix = "carbon.agents.{host}"
+metric-endpoint = "local"
+metric-interval = "1m0s"
+max-cpu = 0
+
+[whisper]
+data-dir = "/data/graphite/whisper"
+workers = 1
+max-updates-per-second = 0
+sparse-create = false
+enabled = true
+
+[cache]
+max-size = 1000000
+write-strategy = "max"
+
+[udp]
+listen = ":2003"
+enabled = false
+
+[tcp]
+listen = ":2003"
+enabled = true
+
+[pickle]
+listen = ":2004"
+enabled = true
+max-message-size = 67108864
+
+[carbonlink]
+listen = ":7007"
+enabled = true
+read-timeout = "30s"
+
+[carbonserver]
+listen = ":7002"
+enabled = true
+buckets = 10
+max-globs = 100
+metrics-as-counters = false
+read-timeout = "60s"
+write-timeout = "60s"
+scan-frequency = "10s"
+max-metrics-globbed = 30000
+max-metrics-rendered = 1000
+file-list-cache = ""
+trigram-index = false
+internal-stats-dir = ""
+query-cache-enabled = false
+
+[logging]
+file = "stdout"
+level = "info"
+encoding = "mixed"
diff --git a/tests/documentation_validation.rs b/tests/documentation_validation.rs
index ad795cc..feb0b36 100644
--- a/tests/documentation_validation.rs
+++ b/tests/documentation_validation.rs
@@ -36,7 +36,7 @@ fn extract_yaml_blocks(content: &str) -> Vec<String> {
 #[test]
 fn validate_yaml_examples_parse() {
     let doc_root = Path::new("doc");
-    
+
     // Check if configuration examples exist
     let examples_path = doc_root.join("configuration/examples.md");
     if !examples_path.exists() {
@@ -44,8 +44,8 @@ fn validate_yaml_examples_parse() {
         return;
     }
 
-    let content = fs::read_to_string(&examples_path)
-        .expect("Failed to read configuration examples");
+    let content =
+        fs::read_to_string(&examples_path).expect("Failed to read configuration examples");
 
     let yaml_blocks = extract_yaml_blocks(&content);
     assert!(
@@ -68,17 +68,16 @@ fn validate_yaml_examples_parse() {
 #[test]
 fn validate_quickstart_examples() {
     let quickstart_path = Path::new("doc/getting-started/quickstart.md");
-    
+
     if !quickstart_path.exists() {
         eprintln!("Quickstart not yet created, skipping test");
         return;
     }
 
-    let content = fs::read_to_string(&quickstart_path)
-        .expect("Failed to read quickstart");
+    let content = fs::read_to_string(&quickstart_path).expect("Failed to read quickstart");
 
     let yaml_blocks = extract_yaml_blocks(&content);
-    
+
     for (i, yaml) in yaml_blocks.iter().enumerate() {
         let parsed: Result<Config, _> = serde_yaml::from_str(yaml);
         assert!(
@@ -99,8 +98,8 @@ fn validate_schema_exists_and_valid() {
         "config-schema.json not found. Run 'cargo build' to generate it."
     );
 
-    let schema_content = fs::read_to_string(schema_path)
-        .expect("Failed to read config-schema.json");
+    let schema_content =
+        fs::read_to_string(schema_path).expect("Failed to read config-schema.json");
 
     let schema: Result<Value, _> = serde_json::from_str(&schema_content);
     assert!(
@@ -129,8 +128,7 @@ fn validate_patterns_json() {
         "patterns.json not found in doc/schemas/"
     );
 
-    let patterns_content = fs::read_to_string(patterns_path)
-        .expect("Failed to read patterns.json");
+    let patterns_content = fs::read_to_string(patterns_path).expect("Failed to read patterns.json");
 
     let patterns: Result<Value, _> = serde_json::from_str(&patterns_content);
     assert!(
@@ -149,8 +147,7 @@ fn validate_schema_readme_exists() {
         "schemas/README.md not found in doc/schemas/"
     );
 
-    let readme_content = fs::read_to_string(readme_path)
-        .expect("Failed to read schemas/README.md");
+    let readme_content = fs::read_to_string(readme_path).expect("Failed to read schemas/README.md");
 
     assert!(
         readme_content.contains("config-schema.json"),
@@ -164,33 +161,33 @@ fn validate_documentation_structure() {
     let summary_path = Path::new("doc/SUMMARY.md");
     assert!(summary_path.exists(), "SUMMARY.md not found");
 
-    let summary_content = fs::read_to_string(summary_path)
-        .expect("Failed to read SUMMARY.md");
+    let summary_content = fs::read_to_string(summary_path).expect("Failed to read SUMMARY.md");
 
     // Extract markdown links
     let link_regex = regex::Regex::new(r"\[([^\]]+)\]\(([^)]+)\)").unwrap();
-    
+
     for cap in link_regex.captures_iter(&summary_content) {
         let link = &cap[2];
-        
+
         // Skip external links
         if link.starts_with("http://") || link.starts_with("https://") {
             continue;
         }
 
         let _link_path = Path::new("doc").join(link);
-        
+
         // Only check links that should exist (not future placeholders)
-        if link.contains("getting-started") || 
-           link.contains("architecture") || 
-           link.contains("api") || 
-           link.contains("configuration") ||
-           link.contains("integration") ||
-           link.contains("modules") ||
-           link.contains("guides") ||
-           link == "index.md" ||
-           link == "convertor.md" ||
-           link == "reporter.md" {
+        if link.contains("getting-started")
+            || link.contains("architecture")
+            || link.contains("api")
+            || link.contains("configuration")
+            || link.contains("integration")
+            || link.contains("modules")
+            || link.contains("guides")
+            || link == "index.md"
+            || link == "convertor.md"
+            || link == "reporter.md"
+        {
             // We'll create these files, so just note them for now
             eprintln!("Link to be created: {}", link);
         }
@@ -202,7 +199,7 @@ fn validate_config_examples_conform_to_schema() {
     // This test will validate that configuration examples conform to the JSON schema
     // For now, we just ensure the schema is valid
     // Future: Use jsonschema crate to validate examples against schema
-    
+
     let schema_path = Path::new("doc/schemas/config-schema.json");
     assert!(schema_path.exists(), "Schema must exist");
 }
diff --git a/tests/fixtures/configs.rs b/tests/fixtures/configs.rs
index 6b83896..845358f 100644
--- a/tests/fixtures/configs.rs
+++ b/tests/fixtures/configs.rs
@@ -5,7 +5,8 @@
 
 /// Empty health metrics configuration for error testing
 pub fn empty_health_config(graphite_url: &str) -> String {
-    format!(r#"
+    format!(
+        r#"
 datasource:
   url: '{}'
 server:
@@ -19,12 +20,15 @@ health_metrics:
     category: compute
     metrics: []
     expressions: []
-"#, graphite_url)
+"#,
+        graphite_url
+    )
 }
 
 /// Configuration with known service for error testing
 pub fn error_test_config(graphite_url: &str) -> String {
-    format!(r#"
+    format!(
+        r#"
 datasource:
   url: '{}'
 server:
@@ -52,5 +56,7 @@ health_metrics:
     expressions:
       - expression: 'webapp.metric1'
         weight: 1
-"#, graphite_url)
+"#,
+        graphite_url
+    )
 }
diff --git a/tests/fixtures/graphite_responses.rs b/tests/fixtures/graphite_responses.rs
index 3d5f643..3a5bbca 100644
--- a/tests/fixtures/graphite_responses.rs
+++ b/tests/fixtures/graphite_responses.rs
@@ -19,7 +19,12 @@ pub fn webapp_cpu_response() -> serde_json::Value {
 }
 
 /// Health metrics response for api-service (cpu, memory, error_rate)
-pub fn api_service_health_response(cpu: f64, memory: f64, error_rate: f64, timestamp: i64) -> serde_json::Value {
+pub fn api_service_health_response(
+    cpu: f64,
+    memory: f64,
+    error_rate: f64,
+    timestamp: i64,
+) -> serde_json::Value {
     json!([
         {"target": "api-service.cpu_usage", "datapoints": [[cpu, timestamp]]},
         {"target": "api-service.memory_usage", "datapoints": [[memory, timestamp]]},
@@ -37,7 +42,11 @@ pub fn api_service_empty_response() -> serde_json::Value {
 }
 
 /// Health metrics response with partial data (some metrics missing datapoints)
-pub fn api_service_partial_response(cpu: f64, error_rate: f64, timestamp: i64) -> serde_json::Value {
+pub fn api_service_partial_response(
+    cpu: f64,
+    error_rate: f64,
+    timestamp: i64,
+) -> serde_json::Value {
     json!([
         {"target": "api-service.cpu_usage", "datapoints": [[cpu, timestamp]]},
         {"target": "api-service.memory_usage", "datapoints": []},
diff --git a/tests/fixtures/helpers.rs b/tests/fixtures/helpers.rs
index b74851e..2b84d20 100644
--- a/tests/fixtures/helpers.rs
+++ b/tests/fixtures/helpers.rs
@@ -3,17 +3,15 @@
 // Provides utilities for creating test state, mocking Graphite responses,
 // and custom assertions for clearer test failure messages
 
-use cloudmon_metrics::{
-    config::Config,
-    types::AppState,
-};
+use cloudmon_metrics::{config::Config, types::AppState};
 
 /// Creates a test AppState for API integration testing with multiple services
 ///
 /// # Arguments
 /// * `graphite_url` - URL of the mock Graphite server
 pub fn create_api_test_state(graphite_url: &str) -> AppState {
-    let config_str = format!(r#"
+    let config_str = format!(
+        r#"
         datasource:
           url: '{}'
         server:
@@ -43,7 +41,9 @@ pub fn create_api_test_state(graphite_url: &str) -> AppState {
             expressions:
               - expression: 'webapp.cpu_usage'
                 weight: 2
-    "#, graphite_url);
+    "#,
+        graphite_url
+    );
 
     let config = Config::from_config_str(&config_str);
     let mut state = AppState::new(config);
@@ -56,7 +56,8 @@ pub fn create_api_test_state(graphite_url: &str) -> AppState {
 /// # Arguments
 /// * `graphite_url` - URL of the mock Graphite server
 pub fn create_health_test_state(graphite_url: &str) -> AppState {
-    let config_str = format!(r#"
+    let config_str = format!(
+        r#"
         datasource:
           url: '{}'
         server:
@@ -110,7 +111,9 @@ pub fn create_health_test_state(graphite_url: &str) -> AppState {
                 weight: 50
               - expression: 'api_service.cpu_usage || api_service.memory_usage || api_service.error_rate'
                 weight: 30
-    "#, graphite_url);
+    "#,
+        graphite_url
+    );
 
     let config = Config::from_config_str(&config_str);
     let mut state = AppState::new(config);
@@ -137,7 +140,6 @@ pub fn assert_health_score(actual: u8, expected: u8, context: &str) {
     );
 }
 
-
 /// Helper to setup a mockito mock with common Graphite query parameters
 ///
 /// # Arguments
diff --git a/tests/integration_api.rs b/tests/integration_api.rs
index 9820d2b..86dd50e 100644
--- a/tests/integration_api.rs
+++ b/tests/integration_api.rs
@@ -15,18 +15,15 @@ use fixtures::{configs, graphite_responses, helpers};
 use serde_json::{json, Value};
 use tower::ServiceExt;
 
-
 /// T059: Create full API integration test with mocked Graphite
 #[tokio::test]
 async fn test_api_integration_with_mocked_graphite() {
     // Create mock Graphite server
     let mut server = mockito::Server::new();
-    
+
     // Mock the /render endpoint to return sample metric data
-    let _mock = helpers::setup_graphite_render_mock(
-        &mut server,
-        graphite_responses::webapp_cpu_response(),
-    );
+    let _mock =
+        helpers::setup_graphite_render_mock(&mut server, graphite_responses::webapp_cpu_response());
 
     // Create application state with mock URL using fixtures
     let state = helpers::create_api_test_state(&server.url());
@@ -36,13 +33,15 @@ async fn test_api_integration_with_mocked_graphite() {
         .nest("/api/v1", api::v1::get_v1_routes())
         .merge(graphite::get_graphite_routes())
         .with_state(state);
-    
+
     // Test 1: API v1 root endpoint
     let request = Request::builder()
         .uri("/api/v1")
         .body(Body::empty())
         .unwrap();
-    let response = ServiceExt::<Request<Body>>::oneshot(app, request).await.unwrap();
+    let response = ServiceExt::<Request<Body>>::oneshot(app, request)
+        .await
+        .unwrap();
     assert_eq!(response.status(), StatusCode::OK);
     let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
     let body: Value = serde_json::from_slice(&body).unwrap();
@@ -64,7 +63,9 @@ async fn test_graphite_endpoints_integration() {
         .uri("/metrics/find?query=*")
         .body(Body::empty())
         .unwrap();
-    let response = ServiceExt::<Request<Body>>::oneshot(app, request).await.unwrap();
+    let response = ServiceExt::<Request<Body>>::oneshot(app, request)
+        .await
+        .unwrap();
     assert_eq!(response.status(), StatusCode::OK);
     let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
     let body: Value = serde_json::from_slice(&body).unwrap();
@@ -86,7 +87,9 @@ async fn test_graphite_utility_endpoints() {
         .uri("/functions")
         .body(Body::empty())
         .unwrap();
-    let response = ServiceExt::<Request<Body>>::oneshot(app1, request).await.unwrap();
+    let response = ServiceExt::<Request<Body>>::oneshot(app1, request)
+        .await
+        .unwrap();
     assert_eq!(response.status(), StatusCode::OK);
     let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
     let body: Value = serde_json::from_slice(&body).unwrap();
@@ -100,7 +103,9 @@ async fn test_graphite_utility_endpoints() {
         .uri("/tags/autoComplete/tags")
         .body(Body::empty())
         .unwrap();
-    let response = ServiceExt::<Request<Body>>::oneshot(app2, request).await.unwrap();
+    let response = ServiceExt::<Request<Body>>::oneshot(app2, request)
+        .await
+        .unwrap();
     assert_eq!(response.status(), StatusCode::OK);
     let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
     let body: Value = serde_json::from_slice(&body).unwrap();
@@ -113,7 +118,7 @@ async fn test_error_response_format() {
     let config_str = configs::empty_health_config("https://mock-graphite.example.com");
     let config = config::Config::from_config_str(&config_str);
     let state = types::AppState::new(config);
-    
+
     let app = Router::new()
         .nest("/api/v1", api::v1::get_v1_routes())
         .with_state(state);
@@ -125,10 +130,10 @@ async fn test_error_response_format() {
         .unwrap();
     let response = app.clone().oneshot(request).await.unwrap();
     assert_eq!(response.status(), StatusCode::CONFLICT);
-    
+
     let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
     let body: Value = serde_json::from_slice(&body).unwrap();
-    
+
     // Verify error response format has "message" field
     assert!(body.get("message").is_some());
     assert!(body["message"].is_string());
@@ -142,7 +147,7 @@ async fn test_error_response_format() {
         .unwrap();
     let response = app.clone().oneshot(request).await.unwrap();
     assert_eq!(response.status(), StatusCode::BAD_REQUEST);
-    
+
     // Test 3: Invalid endpoint (404 NOT_FOUND)
     let request = Request::builder()
         .uri("/api/v1/nonexistent")
@@ -159,7 +164,7 @@ async fn test_health_endpoint_unsupported_environment() {
     let config = config::Config::from_config_str(&config_str);
     let mut state = types::AppState::new(config);
     state.process_config();
-    
+
     let app = Router::new()
         .nest("/api/v1", api::v1::get_v1_routes())
         .with_state(state);
@@ -170,15 +175,55 @@ async fn test_health_endpoint_unsupported_environment() {
         .body(Body::empty())
         .unwrap();
     let response = app.oneshot(request).await.unwrap();
-    
+
     // Should return CONFLICT status
     assert_eq!(response.status(), StatusCode::CONFLICT);
-    
+
     let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
     let body: Value = serde_json::from_slice(&body).unwrap();
-    
+
     // Verify error message format
     assert!(body.get("message").is_some());
     let message = body["message"].as_str().unwrap();
     assert!(message.contains("not supported"));
 }
+
+/// Test INTERNAL_SERVER_ERROR response when Graphite returns an error
+#[tokio::test]
+async fn test_health_endpoint_graphite_error() {
+    let mut server = mockito::Server::new();
+
+    // Mock Graphite to return client error (which triggers GraphiteError)
+    let _mock = server
+        .mock("GET", "/render")
+        .with_status(400)
+        .with_body("Bad Request")
+        .create();
+
+    let config_str = configs::error_test_config(&server.url());
+    let config = config::Config::from_config_str(&config_str);
+    let mut state = types::AppState::new(config);
+    state.process_config();
+
+    let app = Router::new()
+        .nest("/api/v1", api::v1::get_v1_routes())
+        .with_state(state);
+
+    // Request with valid parameters but Graphite will fail
+    let request = Request::builder()
+        .uri("/api/v1/health?service=webapp&environment=prod&from=now-1h&to=now")
+        .body(Body::empty())
+        .unwrap();
+    let response = app.oneshot(request).await.unwrap();
+
+    // Should return INTERNAL_SERVER_ERROR status for GraphiteError
+    assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
+
+    let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
+    let body: Value = serde_json::from_slice(&body).unwrap();
+
+    // Verify error response format has "message" field
+    assert!(body.get("message").is_some());
+    let message = body["message"].as_str().unwrap();
+    assert!(message.contains("Graphite error") || message.contains("error"));
+}
diff --git a/tests/integration_e2e_reporter.rs b/tests/integration_e2e_reporter.rs
new file mode 100644
index 0000000..be7205a
--- /dev/null
+++ b/tests/integration_e2e_reporter.rs
@@ -0,0 +1,1186 @@
+//! # E2E Integration Tests for Reporter Log Validation
+//!
+//! This module contains end-to-end integration tests that validate the complete
+//! metrics-processor pipeline using real Docker containers (go-carbon + carbonapi).
+//!
+//! ## Overview
+//!
+//! These tests verify that the reporter correctly:
+//! - Fetches metrics from Graphite
+//! - Evaluates health expressions
+//! - Creates incidents with correct severity
+//! - Logs all required fields for observability
+//!
+//! ## Prerequisites
+//!
+//! ### Docker
+//! Docker must be installed and running. The test automatically manages containers.
+//!
+//! ### Ports
+//! The following ports must be available:
+//! - `2003` - Carbon plaintext protocol (metrics ingestion)
+//! - `8080` - CarbonAPI (Graphite-compatible query API)
+//! - `3005` - Convertor API
+//! - `9999` - Mock Status Dashboard
+//!
+//! ## Running the Tests
+//!
+//! ### Full E2E Test (recommended)
+//! ```bash
+//! cargo test --test integration_e2e_reporter -- --ignored --nocapture
+//! ```
+//!
+//! ### Unit Tests Only (no Docker required)
+//! ```bash
+//! cargo test --test integration_e2e_reporter
+//! ```
+//!
+//! ## Test Scenarios
+//!
+//! | Scenario | Weight | Expression | Triggered Metrics |
+//! |----------|--------|------------|-------------------|
+//! | healthy | 0 | none | [] |
+//! | degraded_slow | 1 | `api_slow \|\| api_success_rate_low` | [api_slow] |
+//! | degraded_errors | 1 | `api_slow \|\| api_success_rate_low` | [api_success_rate_low] |
+//! | outage | 2 | `api_down` | [api_down, api_success_rate_low] |
+//!
+//! ## Architecture
+//!
+//! ```text
+//! ┌─────────────┐     ┌─────────────┐     ┌─────────────┐
+//! │  Test Code  │────▶│  go-carbon  │────▶│  carbonapi  │
+//! │(write data) │     │  (storage)  │     │   (query)   │
+//! └─────────────┘     └─────────────┘     └─────────────┘
+//!                                                │
+//!       ┌─────────────────────────────────────────┘
+//!       ▼
+//! ┌─────────────┐     ┌─────────────┐     ┌─────────────┐
+//! │  Convertor  │────▶│  Reporter   │────▶│ Mock Status │
+//! │  (process)  │     │   (alert)   │     │  Dashboard  │
+//! └─────────────┘     └─────────────┘     └─────────────┘
+//!       │                   │
+//!       │                   ▼
+//!       │             ┌─────────────┐
+//!       └────────────▶│  Log Output │◀── Test validates
+//!                     │  (stdout)   │
+//!                     └─────────────┘
+//! ```
+//!
+//! ## How It Works
+//!
+//! 1. **Docker Setup**: Test restarts Docker containers to ensure clean Graphite data
+//! 2. **Build Binaries**: Compiles convertor and reporter binaries once
+//! 3. **For Each Scenario**:
+//!    - Generates scenario-specific config (unique service name for data isolation)
+//!    - Starts mock Status Dashboard (Python HTTP server)
+//!    - Starts convertor binary
+//!    - Writes test metrics to Graphite via TCP to Carbon (port 2003)
+//!    - Starts reporter binary and captures stdout
+//!    - Validates log output contains expected fields
+//!    - Cleans up processes
+//!
+//! ## Data Isolation
+//!
+//! Each scenario uses a unique service name (e.g., `rms_healthy`, `rms_outage`) to
+//! prevent data from one scenario affecting another. This allows all scenarios to
+//! run sequentially without clearing Graphite between tests.
+//!
+//! ## Troubleshooting
+//!
+//! ### "Docker containers failed to start"
+//! - Ensure Docker is running: `docker ps`
+//! - Check port availability: `lsof -i :2003 -i :8080`
+//!
+//! ### "Convertor not ready"
+//! - Increase timeout in `wait_for_convertor()`
+//! - Check convertor logs for errors
+//!
+//! ### "No incident log found"
+//! - Verify Graphite received data: `curl 'http://localhost:8080/metrics/find?query=stats.*'`
+//! - Check go-carbon scan frequency in `tests/docker/go-carbon.conf`
+//!
+//! ### "Log validation failed"
+//! - Check for ANSI escape codes in output (test strips them)
+//! - Verify expected expression matches config
+
+use std::io::{BufRead, BufReader, Write};
+use std::net::TcpStream;
+use std::process::{Child, Command, Stdio};
+use std::sync::{Arc, Mutex};
+use std::thread;
+use std::time::Duration;
+
+use regex::Regex;
+
+const GRAPHITE_URL: &str = "http://localhost:8080";
+const CARBON_HOST: &str = "localhost";
+const CARBON_PORT: u16 = 2003;
+const CONVERTOR_PORT: u16 = 3005;
+const STATUS_DASHBOARD_PORT: u16 = 9999;
+
+// ============================================================================
+// Test Infrastructure
+// ============================================================================
+
+/// Check if Graphite/CarbonAPI is available
+async fn is_graphite_available() -> bool {
+    let client = reqwest::Client::new();
+    match client
+        .get(format!("{}/render?format=json", GRAPHITE_URL))
+        .timeout(Duration::from_secs(5))
+        .send()
+        .await
+    {
+        Ok(resp) => resp.status().is_success(),
+        Err(_) => false,
+    }
+}
+
+/// Send metric to Carbon (go-carbon) via TCP
+fn send_metric(metric_path: &str, value: f64, timestamp: i64) -> bool {
+    let metric_line = format!("{} {} {}\n", metric_path, value, timestamp);
+    match TcpStream::connect(format!("{}:{}", CARBON_HOST, CARBON_PORT)) {
+        Ok(mut stream) => {
+            stream.set_write_timeout(Some(Duration::from_secs(5))).ok();
+            match stream.write_all(metric_line.as_bytes()) {
+                Ok(_) => {
+                    println!("  sent: {} = {} @ {}", metric_path, value, timestamp);
+                    true
+                }
+                Err(e) => {
+                    eprintln!("  failed to write: {}", e);
+                    false
+                }
+            }
+        }
+        Err(e) => {
+            eprintln!("  failed to connect to carbon: {}", e);
+            false
+        }
+    }
+}
+
+/// Test scenario configuration with expected log patterns
+///
+/// ## Metric Thresholds (from config)
+///
+/// The test config defines these thresholds for health evaluation:
+/// - `api_slow`: response_time > 1200ms (weight=1, degraded)
+/// - `api_success_rate_low`: success_rate < 65% (weight=1, degraded)
+/// - `api_down`: failed_count == attempted_count (weight=2, outage)
+///
+/// ## How Metrics Are Calculated
+///
+/// - `success_rate` = success_count / attempted_count * 100
+/// - `response_time` = timer mean value in milliseconds
+/// - `api_down` = true when all requests fail (failed_count == attempted_count)
+#[derive(Debug, Clone)]
+struct TestScenario {
+    name: &'static str,
+    description: &'static str,
+    // Metric values
+    failed_count: f64,
+    attempted_count: f64,
+    response_time_ms: f64,
+    success_count: f64,
+    // Expected results
+    expected_weight: u8,
+    // Expected log patterns (what reporter should log)
+    expect_incident_log: bool,
+}
+
+impl TestScenario {
+    /// Get expected expression based on scenario
+    fn expected_expression(&self) -> Option<String> {
+        let service = format!("rms_{}", self.name);
+        match self.name {
+            "healthy" => None,
+            "degraded_slow" | "degraded_errors" => Some(format!(
+                "{}.api_slow || {}.api_success_rate_low",
+                service, service
+            )),
+            "outage" => Some(format!("{}.api_down", service)),
+            _ => None,
+        }
+    }
+
+    /// Get expected triggered metrics based on scenario
+    fn expected_triggered_metrics(&self) -> Vec<String> {
+        let service = format!("rms_{}", self.name);
+        match self.name {
+            "healthy" => vec![],
+            "degraded_slow" => vec![format!("{}.api_slow", service)],
+            "degraded_errors" => vec![format!("{}.api_success_rate_low", service)],
+            "outage" => vec![
+                format!("{}.api_down", service),
+                format!("{}.api_success_rate_low", service),
+            ],
+            _ => vec![],
+        }
+    }
+
+    /// Healthy scenario: all metrics within normal thresholds
+    /// - response_time: 500ms < 1200ms threshold (OK)
+    /// - success_rate: 99/100 = 99% > 65% threshold (OK)
+    /// - failed_count: 0 != attempted_count (not down)
+    /// Result: no incident (weight=0)
+    fn healthy() -> Self {
+        TestScenario {
+            name: "healthy",
+            description: "All metrics healthy - no incident expected",
+            failed_count: 0.0,
+            attempted_count: 100.0,
+            response_time_ms: 500.0,
+            success_count: 99.0,
+            expected_weight: 0,
+            expect_incident_log: false,
+        }
+    }
+
+    /// Degraded (slow) scenario: response time exceeds threshold
+    /// - response_time: 1500ms > 1200ms threshold (TRIGGERS api_slow)
+    /// - success_rate: 99/100 = 99% > 65% threshold (OK)
+    /// Result: degraded incident (weight=1)
+    fn degraded_slow() -> Self {
+        TestScenario {
+            name: "degraded_slow",
+            description: "API slow - degraded incident expected (weight=1)",
+            failed_count: 0.0,
+            attempted_count: 100.0,
+            response_time_ms: 1500.0,
+            success_count: 99.0,
+            expected_weight: 1,
+            expect_incident_log: true,
+        }
+    }
+
+    /// Degraded (errors) scenario: success rate below threshold
+    /// - response_time: 500ms < 1200ms threshold (OK)
+    /// - success_rate: 50/100 = 50% < 65% threshold (TRIGGERS api_success_rate_low)
+    /// Result: degraded incident (weight=1)
+    fn degraded_errors() -> Self {
+        TestScenario {
+            name: "degraded_errors",
+            description: "Low success rate - degraded incident expected (weight=1)",
+            failed_count: 0.0,
+            attempted_count: 100.0,
+            response_time_ms: 500.0,
+            success_count: 50.0,
+            expected_weight: 1,
+            expect_incident_log: true,
+        }
+    }
+
+    /// Outage scenario: all requests failed
+    /// - failed_count: 100 == attempted_count: 100 (TRIGGERS api_down, weight=2)
+    /// - success_rate: 0/100 = 0% < 65% threshold (also triggers api_success_rate_low)
+    /// Result: outage incident (weight=2, highest severity wins)
+    fn outage() -> Self {
+        TestScenario {
+            name: "outage",
+            description: "API down - outage incident expected (weight=2)",
+            failed_count: 100.0,
+            attempted_count: 100.0,
+            response_time_ms: 0.0,
+            success_count: 0.0,
+            expected_weight: 2,
+            expect_incident_log: true,
+        }
+    }
+}
+
+/// Write test data to Graphite for a scenario
+/// Uses scenario-specific metric paths to isolate data between scenarios
+fn write_scenario_data(scenario: &TestScenario, base_timestamp: i64) {
+    println!("\npopulating data for scenario: {}", scenario.name);
+    println!("   {}", scenario.description);
+
+    // Use scenario name in path to isolate data between scenarios
+    let base = format!(
+        "stats.counters.openstack.api.production_eu-de.identity.rms_{}.v3.tokens",
+        scenario.name
+    );
+    let timer_base = format!(
+        "stats.timers.openstack.api.production_eu-de.identity.rms_{}.v3.tokens.GET",
+        scenario.name
+    );
+
+    // Send data at multiple timestamps to ensure coverage across the query window
+    // Graphite aggregates at minute boundaries, so we send at 0, 60, 120, 180 seconds back
+    for offset in [0, 60, 120, 180] {
+        let timestamp = base_timestamp - offset;
+        send_metric(
+            &format!("{}.failed.count", base),
+            scenario.failed_count,
+            timestamp,
+        );
+        send_metric(
+            &format!("{}.attempted.count", base),
+            scenario.attempted_count,
+            timestamp,
+        );
+        send_metric(
+            &format!("{}.mean", timer_base),
+            scenario.response_time_ms,
+            timestamp,
+        );
+        send_metric(
+            &format!("{}.200.count", base),
+            scenario.success_count,
+            timestamp,
+        );
+    }
+
+    // Give Graphite time to process and persist
+    // After container restart, Graphite needs more time to be fully ready
+    println!("   waiting for graphite to process data...");
+    std::thread::sleep(Duration::from_secs(10));
+}
+
+// ============================================================================
+// Expected Log Entry Patterns
+// ============================================================================
+
+/// Expected log entry fields for validation
+#[derive(Debug, Clone)]
+struct ExpectedLogEntry {
+    environment: String,
+    service: String,
+    component_name: String,
+    impact: u8,
+    matched_expression: String,
+    triggered_metrics_contain: Vec<String>,
+}
+
+impl ExpectedLogEntry {
+    fn from_scenario(scenario: &TestScenario) -> Option<Self> {
+        if !scenario.expect_incident_log {
+            return None;
+        }
+
+        Some(ExpectedLogEntry {
+            environment: "production_eu-de".to_string(),
+            service: "config".to_string(),
+            component_name: "Config".to_string(),
+            impact: scenario.expected_weight,
+            matched_expression: scenario
+                .expected_expression()
+                .unwrap_or_else(|| "none".to_string()),
+            triggered_metrics_contain: scenario.expected_triggered_metrics(),
+        })
+    }
+}
+
+/// Validate that a log line contains expected fields
+fn validate_log_line(log_line: &str, expected: &ExpectedLogEntry) -> Vec<String> {
+    let mut errors = Vec::new();
+
+    // Strip ANSI escape codes (color codes from tracing)
+    // ANSI codes are in format \x1b[...m where ... is numbers/semicolons
+    let re = Regex::new(r"\x1b\[[0-9;]*m").unwrap();
+    let clean_log = re.replace_all(log_line, "").to_string();
+
+    // Check environment field
+    let env_pattern = format!("environment=\"{}\"", expected.environment);
+    if !clean_log.contains(&env_pattern) {
+        errors.push(format!(
+            "Missing or wrong environment: expected '{}' in log",
+            env_pattern
+        ));
+    }
+
+    // Check service field
+    let service_pattern = format!("service=\"{}\"", expected.service);
+    if !clean_log.contains(&service_pattern) {
+        errors.push(format!(
+            "Missing or wrong service: expected '{}' in log",
+            service_pattern
+        ));
+    }
+
+    // Check component_name field
+    let component_pattern = format!("component_name=\"{}\"", expected.component_name);
+    if !clean_log.contains(&component_pattern) {
+        errors.push(format!(
+            "Missing or wrong component_name: expected '{}' in log",
+            component_pattern
+        ));
+    }
+
+    // Check impact field
+    let impact_pattern = format!("impact={}", expected.impact);
+    if !clean_log.contains(&impact_pattern) {
+        errors.push(format!(
+            "Missing or wrong impact: expected '{}' in log",
+            impact_pattern
+        ));
+    }
+
+    // Check matched_expression field
+    let expr_pattern = format!("matched_expression=\"{}\"", expected.matched_expression);
+    if !clean_log.contains(&expr_pattern) {
+        errors.push(format!(
+            "Missing or wrong matched_expression: expected '{}' in log",
+            expr_pattern
+        ));
+    }
+
+    // Check triggered_metrics contains expected metric names
+    for metric in &expected.triggered_metrics_contain {
+        if !clean_log.contains(metric) {
+            errors.push(format!(
+                "triggered_metrics missing '{}' in log line",
+                metric
+            ));
+        }
+    }
+
+    // Verify the log message indicates incident creation
+    if !clean_log.contains("creating incident") {
+        errors.push("Missing 'creating incident' message in log".to_string());
+    }
+
+    errors
+}
+
+// ============================================================================
+// Process Management
+// ============================================================================
+
+/// Kill any existing process on a port
+fn kill_process_on_port(port: u16) {
+    // Try to kill any existing process on the port
+    let _ = Command::new("lsof")
+        .args(["-ti", &format!(":{}", port)])
+        .output()
+        .map(|output| {
+            if output.status.success() {
+                let pids = String::from_utf8_lossy(&output.stdout);
+                for pid in pids.trim().lines() {
+                    if let Ok(pid_num) = pid.trim().parse::<i32>() {
+                        let _ = Command::new("kill").arg(pid_num.to_string()).output();
+                    }
+                }
+            }
+        });
+    std::thread::sleep(Duration::from_millis(100));
+}
+
+/// Start mock Status Dashboard server
+fn start_mock_status_dashboard() -> Option<Child> {
+    // Clean up any existing process on the port
+    kill_process_on_port(STATUS_DASHBOARD_PORT);
+
+    // Use a Python HTTP server that supports IPv4/IPv6 and runs indefinitely
+    let mock_server = Command::new("python3")
+        .args([
+            "-c",
+            &format!(
+                r#"
+import http.server
+import json
+import socketserver
+import socket
+
+class Handler(http.server.BaseHTTPRequestHandler):
+    def do_GET(self):
+        if '/v2/components' in self.path:
+            self.send_response(200)
+            self.send_header('Content-Type', 'application/json')
+            self.end_headers()
+            response = json.dumps([
+                {{"id": 218, "name": "Config", "attributes": [{{"name": "region", "value": "EU-DE"}}]}}
+            ])
+            self.wfile.write(response.encode())
+        else:
+            self.send_response(404)
+            self.end_headers()
+
+    def do_POST(self):
+        if '/v2/events' in self.path:
+            self.send_response(200)
+            self.send_header('Content-Type', 'application/json')
+            self.end_headers()
+            response = json.dumps({{"result": [{{"component_id": 218, "incident_id": 1}}]}})
+            self.wfile.write(response.encode())
+        else:
+            self.send_response(404)
+            self.end_headers()
+
+    def log_message(self, format, *args):
+        pass  # Suppress logging
+
+class DualStackTCPServer(socketserver.TCPServer):
+    address_family = socket.AF_INET6
+    allow_reuse_address = True
+    
+    def server_bind(self):
+        self.socket.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
+        super().server_bind()
+
+server = DualStackTCPServer(('::', {}), Handler)
+server.serve_forever()
+"#,
+                STATUS_DASHBOARD_PORT
+            ),
+        ])
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .spawn();
+
+    match mock_server {
+        Ok(child) => {
+            // Wait for server to be ready with retry loop
+            let start = std::time::Instant::now();
+            let timeout = Duration::from_secs(5);
+            let mut ready = false;
+
+            while start.elapsed() < timeout {
+                match std::net::TcpStream::connect_timeout(
+                    &format!("127.0.0.1:{}", STATUS_DASHBOARD_PORT)
+                        .parse()
+                        .unwrap(),
+                    Duration::from_millis(100),
+                ) {
+                    Ok(_) => {
+                        ready = true;
+                        break;
+                    }
+                    Err(_) => std::thread::sleep(Duration::from_millis(100)),
+                }
+            }
+
+            if ready {
+                println!(
+                    "mock status dashboard started on port {}",
+                    STATUS_DASHBOARD_PORT
+                );
+                Some(child)
+            } else {
+                eprintln!("mock status dashboard not ready after timeout");
+                None
+            }
+        }
+        Err(e) => {
+            eprintln!("failed to start mock status dashboard: {}", e);
+            None
+        }
+    }
+}
+
+/// Start the convertor process
+#[allow(dead_code)]
+fn start_convertor(config_path: &str) -> Option<Child> {
+    let convertor = Command::new("cargo")
+        .args([
+            "run",
+            "--bin",
+            "cloudmon-metrics-convertor",
+            "--",
+            "-c",
+            config_path,
+        ])
+        .env("RUST_LOG", "info")
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn();
+
+    match convertor {
+        Ok(child) => {
+            // Give convertor time to start
+            std::thread::sleep(Duration::from_secs(3));
+            println!("convertor started");
+            Some(child)
+        }
+        Err(e) => {
+            eprintln!("failed to start convertor: {}", e);
+            None
+        }
+    }
+}
+
+/// Start the reporter process and capture its output
+#[allow(dead_code)]
+fn start_reporter_with_output_capture(
+    config_path: &str,
+) -> Option<(Child, Arc<Mutex<Vec<String>>>)> {
+    let reporter = Command::new("cargo")
+        .args([
+            "run",
+            "--bin",
+            "cloudmon-metrics-reporter",
+            "--",
+            "-c",
+            config_path,
+        ])
+        .env("RUST_LOG", "info")
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn();
+
+    match reporter {
+        Ok(mut child) => {
+            let logs: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(Vec::new()));
+            let logs_clone = logs.clone();
+
+            // Capture stderr (where tracing logs go)
+            if let Some(stderr) = child.stderr.take() {
+                thread::spawn(move || {
+                    let reader = BufReader::new(stderr);
+                    for line in reader.lines().map_while(Result::ok) {
+                        println!("  [reporter] {}", line);
+                        let mut log_vec = logs_clone.lock().unwrap();
+                        log_vec.push(line);
+                    }
+                });
+            }
+
+            // Give reporter time to start
+            std::thread::sleep(Duration::from_secs(2));
+            println!("reporter started with log capture");
+            Some((child, logs))
+        }
+        Err(e) => {
+            eprintln!("failed to start reporter: {}", e);
+            None
+        }
+    }
+}
+
+/// Check if convertor API is ready
+async fn wait_for_convertor(timeout_secs: u64) -> bool {
+    let client = reqwest::Client::new();
+    let start = std::time::Instant::now();
+
+    while start.elapsed().as_secs() < timeout_secs {
+        match client
+            .get(format!("http://localhost:{}/api/v1", CONVERTOR_PORT))
+            .timeout(Duration::from_secs(2))
+            .send()
+            .await
+        {
+            Ok(resp) if resp.status().is_success() => {
+                println!("convertor api ready at port {}", CONVERTOR_PORT);
+                return true;
+            }
+            _ => {
+                std::thread::sleep(Duration::from_millis(500));
+            }
+        }
+    }
+
+    eprintln!("convertor api not ready after {} seconds", timeout_secs);
+    false
+}
+
+// ============================================================================
+// E2E Tests
+// ============================================================================
+
+/// Restart docker containers to clear graphite data
+/// This ensures each test run starts with clean state
+fn restart_docker_containers() -> bool {
+    println!("restarting docker containers to clear graphite data...");
+
+    // Stop containers
+    let stop = Command::new("docker")
+        .args([
+            "compose",
+            "-f",
+            "tests/docker/docker-compose.yml",
+            "down",
+            "-v",
+        ])
+        .output();
+
+    if let Err(e) = stop {
+        eprintln!("warning: failed to stop containers: {}", e);
+    }
+
+    // Start containers
+    let start = Command::new("docker")
+        .args([
+            "compose",
+            "-f",
+            "tests/docker/docker-compose.yml",
+            "up",
+            "-d",
+        ])
+        .output();
+
+    match start {
+        Ok(result) if result.status.success() => {
+            println!("docker containers restarted");
+            // Wait for services to be ready - graphite needs time to initialize
+            println!("waiting for graphite to be ready...");
+            std::thread::sleep(Duration::from_secs(15));
+            true
+        }
+        Ok(result) => {
+            eprintln!(
+                "failed to start containers: {}",
+                String::from_utf8_lossy(&result.stderr)
+            );
+            false
+        }
+        Err(e) => {
+            eprintln!("failed to run docker compose: {}", e);
+            false
+        }
+    }
+}
+
+/// Build binaries once before running tests
+fn build_binaries() -> bool {
+    println!("building binaries...");
+    let output = Command::new("cargo")
+        .args([
+            "build",
+            "--bin",
+            "cloudmon-metrics-convertor",
+            "--bin",
+            "cloudmon-metrics-reporter",
+        ])
+        .output();
+
+    match output {
+        Ok(result) => {
+            if result.status.success() {
+                println!("binaries built successfully");
+                true
+            } else {
+                eprintln!(
+                    "failed to build binaries: {}",
+                    String::from_utf8_lossy(&result.stderr)
+                );
+                false
+            }
+        }
+        Err(e) => {
+            eprintln!("failed to run cargo build: {}", e);
+            false
+        }
+    }
+}
+
+/// Get path to compiled binary
+fn get_binary_path(name: &str) -> String {
+    format!("./target/debug/{}", name)
+}
+
+/// Generate config for a specific scenario
+/// Uses scenario-specific service name to isolate data between scenarios
+fn generate_config(scenario_name: &str) -> String {
+    // Use scenario-specific service name (e.g., "rms_healthy", "rms_outage")
+    let service = format!("rms_{}", scenario_name);
+
+    format!(
+        r#"
+datasource:
+  url: '{}'
+  timeout: 30
+
+server:
+  port: {}
+  address: '0.0.0.0'
+
+status_dashboard:
+  url: 'http://localhost:{}'
+  secret: 'test-secret-key'
+
+metric_templates:
+  api_down:
+    query: "asPercent(smartSummarize(sumSeries(stats.counters.openstack.api.$environment.*.$service.*.*.failed.count), '1min', 'average', '1min'), smartSummarize(sumSeries(stats.counters.openstack.api.$environment.*.$service.*.*.attempted.count), '1min', 'average', '1min'))"
+    op: "eq"
+    threshold: 100
+
+  api_slow:
+    query: "smartSummarize(consolidateBy(aggregate(stats.timers.openstack.api.$environment.*.$service.*.*.*.mean, 'average'), 'average'), '3min', 'average')"
+    op: "gt"
+    threshold: 1200
+
+  api_success_rate_low:
+    query: "smartSummarize(asPercent(sumSeries(stats.counters.openstack.api.$environment.*.$service.*.*.{{{{2*,3*,404}}}}.count), sumSeries(stats.counters.openstack.api.$environment.*.$service.*.*.attempted.count)), '3min', 'average')"
+    op: "lt"
+    threshold: 65
+
+environments:
+  - name: production_eu-de
+    attributes:
+      region: EU-DE
+
+flag_metrics:
+  - name: "api_down"
+    service: "{}"
+    template:
+      name: "api_down"
+    environments:
+      - name: "production_eu-de"
+
+  - name: "api_slow"
+    service: "{}"
+    template:
+      name: "api_slow"
+    environments:
+      - name: "production_eu-de"
+
+  - name: "api_success_rate_low"
+    service: "{}"
+    template:
+      name: "api_success_rate_low"
+    environments:
+      - name: "production_eu-de"
+
+health_metrics:
+  config:
+    service: {}
+    component_name: "Config"
+    category: management
+    metrics:
+      - {}.api_slow
+      - {}.api_down
+      - {}.api_success_rate_low
+    expressions:
+      - expression: "{}.api_slow || {}.api_success_rate_low"
+        weight: 1
+      - expression: "{}.api_down"
+        weight: 2
+
+health_query:
+  query_from: "-5min"
+  query_to: "-1min"
+"#,
+        GRAPHITE_URL,
+        CONVERTOR_PORT,
+        STATUS_DASHBOARD_PORT,
+        service,
+        service,
+        service,
+        service,
+        service,
+        service,
+        service,
+        service,
+        service,
+        service
+    )
+}
+
+/// Main E2E test that runs all scenarios and validates reporter log output
+#[tokio::test]
+#[ignore] // Run with: cargo test --test integration_e2e_reporter -- --ignored --nocapture
+async fn test_e2e_reporter_log_validation() {
+    println!("\ne2e reporter log validation test");
+    println!("====================================\n");
+
+    // Restart docker containers to ensure clean graphite data
+    // This prevents stale data from previous test runs affecting results
+    assert!(
+        restart_docker_containers(),
+        "failed to restart docker containers"
+    );
+
+    // Check if Graphite is available - FAIL if not
+    assert!(
+        is_graphite_available().await,
+        "graphite not available at {}. start with: cd tests/docker && docker compose up -d",
+        GRAPHITE_URL
+    );
+    println!("graphite is available at {}\n", GRAPHITE_URL);
+
+    // Build binaries first
+    assert!(build_binaries(), "failed to build binaries");
+
+    // Test each scenario - now with isolated metric paths per scenario
+    let scenarios = vec![
+        TestScenario::healthy(),
+        TestScenario::degraded_slow(),
+        TestScenario::degraded_errors(),
+        TestScenario::outage(),
+    ];
+
+    let mut all_passed = true;
+    let mut scenarios_run = 0;
+    let config_path = "config.yaml";
+
+    for scenario in scenarios {
+        println!("\n============================================================");
+        println!("test scenario: {}", scenario.name.to_uppercase());
+        println!("   {}", scenario.description);
+        println!("============================================================");
+
+        // Generate per-scenario config with unique service name to isolate data
+        let config_content = generate_config(&scenario.name);
+        std::fs::write(config_path, &config_content).expect("failed to write config file");
+        println!("scenario config written to {}", config_path);
+
+        // Start mock Status Dashboard
+        let mut mock_sd = start_mock_status_dashboard();
+        assert!(
+            mock_sd.is_some(),
+            "failed to start mock status dashboard for scenario: {}",
+            scenario.name
+        );
+
+        // Start convertor using pre-built binary (uses config.yaml in current dir)
+        let convertor_bin = get_binary_path("cloudmon-metrics-convertor");
+        let mut convertor = match Command::new(&convertor_bin)
+            .env("RUST_LOG", "info")
+            .stdout(Stdio::null())
+            .stderr(Stdio::piped())
+            .spawn()
+        {
+            Ok(c) => c,
+            Err(e) => {
+                if let Some(ref mut sd) = mock_sd {
+                    let _ = sd.kill();
+                }
+                panic!(
+                    "failed to start convertor for scenario {}: {}",
+                    scenario.name, e
+                );
+            }
+        };
+
+        // Wait for convertor to be ready
+        std::thread::sleep(Duration::from_secs(2));
+        if !wait_for_convertor(15).await {
+            let _ = convertor.kill();
+            if let Some(ref mut sd) = mock_sd {
+                let _ = sd.kill();
+            }
+            panic!(
+                "convertor not ready after 15 seconds for scenario: {}",
+                scenario.name
+            );
+        }
+
+        // Write test data to Graphite - use current time as base
+        // The function will send data at multiple timestamps (now, now-60, now-120, now-180)
+        let timestamp = chrono::Utc::now().timestamp();
+        write_scenario_data(&scenario, timestamp);
+
+        // Start reporter using pre-built binary and capture logs (uses config.yaml in current dir)
+        let reporter_bin = get_binary_path("cloudmon-metrics-reporter");
+        let logs: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(Vec::new()));
+
+        let mut reporter = match Command::new(&reporter_bin)
+            .env("RUST_LOG", "info")
+            .stdout(Stdio::piped()) // Capture stdout, not stderr - reporter logs to stdout
+            .stderr(Stdio::null())
+            .spawn()
+        {
+            Ok(mut r) => {
+                // Start stdout reader thread immediately
+                if let Some(stdout) = r.stdout.take() {
+                    let logs_clone = logs.clone();
+                    thread::spawn(move || {
+                        let reader = BufReader::new(stdout);
+                        for line in reader.lines() {
+                            match line {
+                                Ok(l) => {
+                                    println!("  [reporter] {}", l);
+                                    logs_clone.lock().unwrap().push(l);
+                                }
+                                Err(_) => break,
+                            }
+                        }
+                    });
+                }
+                r
+            }
+            Err(e) => {
+                let _ = convertor.kill();
+                if let Some(ref mut sd) = mock_sd {
+                    let _ = sd.kill();
+                }
+                panic!(
+                    "failed to start reporter for scenario {}: {}",
+                    scenario.name, e
+                );
+            }
+        };
+
+        println!("   reporter started (pid: {:?})", reporter.id());
+        scenarios_run += 1;
+
+        // Wait for reporter to process metrics (one iteration)
+        println!("   waiting for reporter to process metrics...");
+        std::thread::sleep(Duration::from_secs(10));
+
+        // Check if reporter is still running
+        match reporter.try_wait() {
+            Ok(Some(status)) => println!("   reporter exited early with status: {:?}", status),
+            Ok(None) => println!("   reporter is still running"),
+            Err(e) => println!("   error checking reporter status: {}", e),
+        }
+
+        // Stop reporter
+        let _ = reporter.kill();
+        let _ = reporter.wait();
+
+        // Give the reader thread time to finish reading
+        std::thread::sleep(Duration::from_millis(500));
+
+        // Get captured logs
+        let captured_logs = logs.lock().unwrap().clone();
+
+        // Print captured logs for debugging
+        println!("   captured {} log lines", captured_logs.len());
+        for line in &captured_logs {
+            println!("  [reporter] {}", line);
+        }
+
+        // Validate log output
+        println!("\nvalidating log output for scenario: {}", scenario.name);
+
+        if let Some(expected) = ExpectedLogEntry::from_scenario(&scenario) {
+            // Find the incident creation log line
+            let incident_log = captured_logs
+                .iter()
+                .find(|line| line.contains("creating incident"));
+
+            match incident_log {
+                Some(log_line) => {
+                    println!("   found incident log: {}", log_line);
+
+                    let errors = validate_log_line(log_line, &expected);
+                    if errors.is_empty() {
+                        println!("   all log fields validated successfully");
+                    } else {
+                        println!("   log validation errors:");
+                        for err in &errors {
+                            println!("      - {}", err);
+                        }
+                        all_passed = false;
+                    }
+
+                    // Print expected vs actual comparison
+                    println!("\n   expected log fields:");
+                    println!("      environment=\"{}\"", expected.environment);
+                    println!("      service=\"{}\"", expected.service);
+                    println!("      component_name=\"{}\"", expected.component_name);
+                    println!("      impact={}", expected.impact);
+                    println!(
+                        "      matched_expression=\"{}\"",
+                        expected.matched_expression
+                    );
+                    println!(
+                        "      triggered_metrics should contain: {:?}",
+                        expected.triggered_metrics_contain
+                    );
+                }
+                None => {
+                    println!("   expected incident log not found!");
+                    println!("   captured logs ({} lines):", captured_logs.len());
+                    for (i, line) in captured_logs.iter().enumerate().take(20) {
+                        println!("      {}: {}", i, line);
+                    }
+                    all_passed = false;
+                }
+            }
+        } else {
+            // Healthy scenario - should NOT have incident log
+            let has_incident = captured_logs
+                .iter()
+                .any(|line| line.contains("creating incident"));
+
+            if has_incident {
+                println!("   unexpected incident log found for healthy scenario!");
+                all_passed = false;
+            } else {
+                println!("   no incident log (expected for healthy scenario)");
+            }
+        }
+
+        // Cleanup
+        let _ = convertor.kill();
+        if let Some(ref mut sd) = mock_sd {
+            let _ = sd.kill();
+        }
+
+        // Brief pause between scenarios
+        std::thread::sleep(Duration::from_secs(2));
+    }
+
+    // Clean up config file
+    let _ = std::fs::remove_file(config_path);
+
+    // Ensure all scenarios were run
+    assert_eq!(
+        scenarios_run, 4,
+        "expected to run 4 scenarios, but only ran {}",
+        scenarios_run
+    );
+
+    println!("\n============================================================");
+    if all_passed {
+        println!(
+            "all e2e reporter tests passed ({} scenarios)",
+            scenarios_run
+        );
+    } else {
+        println!("some e2e reporter tests failed");
+    }
+    println!("============================================================\n");
+
+    assert!(
+        all_passed,
+        "e2e reporter tests failed - see output above for details"
+    );
+}
+
+/// Helper test to verify log line validation logic
+#[test]
+fn test_log_line_validation() {
+    let expected = ExpectedLogEntry {
+        environment: "production_eu-de".to_string(),
+        service: "config".to_string(),
+        component_name: "Config".to_string(),
+        impact: 1,
+        matched_expression: "rms.api_slow || rms.api_success_rate_low".to_string(),
+        triggered_metrics_contain: vec!["rms.api_slow".to_string()],
+    };
+
+    // Test with valid log line
+    let valid_log = r#"2024-01-22T10:30:45.123456Z  INFO cloudmon_metrics_reporter: environment="production_eu-de" service="config" component_name="Config" component_id=218 query_from="-5min" query_to="-1min" metric_timestamp=1705929045 impact=1 triggered_metrics=["rms.api_slow(query=..., op=gt, threshold=1200)"] matched_expression="rms.api_slow || rms.api_success_rate_low" creating incident: health metric indicates service degradation"#;
+
+    let errors = validate_log_line(valid_log, &expected);
+    assert!(errors.is_empty(), "Valid log should pass: {:?}", errors);
+
+    // Test with missing field
+    let invalid_log = r#"environment="wrong_env" service="config" impact=1 matched_expression="rms.api_slow || rms.api_success_rate_low" creating incident"#;
+
+    let errors = validate_log_line(invalid_log, &expected);
+    assert!(!errors.is_empty(), "Invalid log should have errors");
+    assert!(
+        errors.iter().any(|e| e.contains("environment")),
+        "Should detect wrong environment"
+    );
+}
+
+/// Test scenario field population
+#[test]
+fn test_scenario_expected_log_entries() {
+    // Healthy scenario should not produce incident log
+    let healthy = TestScenario::healthy();
+    assert!(!healthy.expect_incident_log);
+    assert!(ExpectedLogEntry::from_scenario(&healthy).is_none());
+
+    // Degraded slow should produce incident log
+    let degraded = TestScenario::degraded_slow();
+    assert!(degraded.expect_incident_log);
+    let expected = ExpectedLogEntry::from_scenario(&degraded).unwrap();
+    assert_eq!(expected.impact, 1);
+    assert_eq!(
+        expected.matched_expression,
+        "rms_degraded_slow.api_slow || rms_degraded_slow.api_success_rate_low"
+    );
+
+    // Outage should produce incident log with weight=2
+    let outage = TestScenario::outage();
+    assert!(outage.expect_incident_log);
+    let expected = ExpectedLogEntry::from_scenario(&outage).unwrap();
+    assert_eq!(expected.impact, 2);
+    assert_eq!(expected.matched_expression, "rms_outage.api_down");
+}
diff --git a/tests/integration_health.rs b/tests/integration_health.rs
index b5bd9dc..c23fa7f 100644
--- a/tests/integration_health.rs
+++ b/tests/integration_health.rs
@@ -1,5 +1,5 @@
 // Integration tests for service health calculation
-// 
+//
 // These tests verify end-to-end health calculation flows with mocked Graphite responses
 
 mod fixtures;
@@ -12,7 +12,7 @@ use fixtures::{graphite_responses, helpers};
 async fn test_integration_health_calculation_end_to_end() {
     let mut server = mockito::Server::new_async().await;
     let mock_url = server.url();
-    
+
     let state = helpers::create_health_test_state(&mock_url);
 
     // Mock Graphite response with all three metrics
@@ -31,11 +31,14 @@ async fn test_integration_health_calculation_end_to_end() {
         100,
     )
     .await;
-    
-    assert!(result.is_ok(), "End-to-end health calculation should succeed");
+
+    assert!(
+        result.is_ok(),
+        "End-to-end health calculation should succeed"
+    );
     let health_data = result.unwrap();
     assert_eq!(health_data.len(), 1, "Should have one datapoint");
-    
+
     // Error rate is 10.0 (> 5.0), so error_rate flag is false
     // CPU (50 < 80) and memory (60 < 90) are normal, so those flags are true
     // Expression evaluation:
@@ -44,9 +47,9 @@ async fn test_integration_health_calculation_end_to_end() {
     // - "cpu || memory || error": true → weight 30
     // Highest matching expression = 50
     helpers::assert_health_score(
-        health_data[0].1,
+        health_data[0].weight,
         50,
-        "cpu && memory should match since both resource metrics are true"
+        "cpu && memory should match since both resource metrics are true",
     );
 }
 
@@ -55,7 +58,7 @@ async fn test_integration_health_calculation_end_to_end() {
 async fn test_integration_complex_weighted_expressions() {
     let mut server = mockito::Server::new_async().await;
     let mock_url = server.url();
-    
+
     let state = helpers::create_health_test_state(&mock_url);
 
     // Mock Graphite response
@@ -74,19 +77,22 @@ async fn test_integration_complex_weighted_expressions() {
         100,
     )
     .await;
-    
-    assert!(result.is_ok(), "Complex weighted expressions should succeed");
+
+    assert!(
+        result.is_ok(),
+        "Complex weighted expressions should succeed"
+    );
     let health_data = result.unwrap();
-    
+
     // All flags are true:
     // - error_rate: 2.0 < 5.0 = true → weight 100
     // - cpu && memory: true && true = true → weight 50
     // - cpu || memory || error: true → weight 30
     // Highest weight = 100
     helpers::assert_health_score(
-        health_data[0].1,
+        health_data[0].weight,
         100,
-        "highest weight (100) when error_rate flag is true"
+        "highest weight (100) when error_rate flag is true",
     );
 }
 
@@ -95,7 +101,7 @@ async fn test_integration_complex_weighted_expressions() {
 async fn test_integration_edge_cases_empty_and_partial_data() {
     let mut server = mockito::Server::new_async().await;
     let mock_url = server.url();
-    
+
     let state = helpers::create_health_test_state(&mock_url);
 
     // Test 1: Empty datapoints array
@@ -113,12 +119,19 @@ async fn test_integration_edge_cases_empty_and_partial_data() {
         100,
     )
     .await;
-    
+
     // Empty datapoints should result in empty health data
-    assert!(result.is_ok(), "Empty datapoints should be handled gracefully");
+    assert!(
+        result.is_ok(),
+        "Empty datapoints should be handled gracefully"
+    );
     let health_data = result.unwrap();
-    assert_eq!(health_data.len(), 0, "Empty datapoints should produce empty result");
-    
+    assert_eq!(
+        health_data.len(),
+        0,
+        "Empty datapoints should produce empty result"
+    );
+
     // Test 2: Partial data (some metrics missing datapoints)
     let _mock2 = helpers::setup_graphite_render_mock_async(
         &mut server,
@@ -134,21 +147,24 @@ async fn test_integration_edge_cases_empty_and_partial_data() {
         100,
     )
     .await;
-    
+
     // Partial data: only metrics with datapoints are evaluated
     // Missing metrics default to false in expression context
     assert!(result2.is_ok(), "Partial data should be handled gracefully");
     let health_data2 = result2.unwrap();
-    assert!(health_data2.len() > 0, "Should have results for timestamps with partial data");
-    
+    assert!(
+        health_data2.len() > 0,
+        "Should have results for timestamps with partial data"
+    );
+
     // With cpu=true, memory=false (missing), error=true:
     // - error_rate alone: true → 100
     // - cpu && memory: true && false = false
     // - cpu || memory || error: true → 30
     // Highest = 100
     helpers::assert_health_score(
-        health_data2[0].1,
+        health_data2[0].weight,
         100,
-        "Partial data should evaluate expressions correctly with missing metrics as false"
+        "Partial data should evaluate expressions correctly with missing metrics as false",
     );
 }
diff --git a/tests/integration_sd.rs b/tests/integration_sd.rs
new file mode 100644
index 0000000..860acea
--- /dev/null
+++ b/tests/integration_sd.rs
@@ -0,0 +1,556 @@
+//! Integration tests for Status Dashboard API integration
+//!
+//! Tests for Phase 7: Integration Testing
+//! T028-T037: Validate end-to-end Status Dashboard API integration with mocked endpoints
+
+use chrono::DateTime;
+use cloudmon_metrics::sd::{
+    build_auth_headers, build_component_id_cache, build_incident_data, create_incident,
+    fetch_components, find_component_id, Component, ComponentAttribute, IncidentData,
+    StatusDashboardComponent,
+};
+
+/// T029: Test fetch_components_success - verify component fetching and parsing
+#[tokio::test]
+async fn test_fetch_components_success() {
+    let mut server = mockito::Server::new_async().await;
+
+    // Mock GET /v2/components endpoint
+    let mock = server
+        .mock("GET", "/v2/components")
+        .with_status(200)
+        .with_header("content-type", "application/json")
+        .with_body(
+            r#"[
+                {
+                    "id": 218,
+                    "name": "Object Storage Service",
+                    "attributes": [
+                        {"name": "category", "value": "Storage"},
+                        {"name": "region", "value": "EU-DE"}
+                    ]
+                },
+                {
+                    "id": 254,
+                    "name": "Compute Service",
+                    "attributes": [
+                        {"name": "category", "value": "Compute"},
+                        {"name": "region", "value": "EU-NL"}
+                    ]
+                }
+            ]"#,
+        )
+        .create_async()
+        .await;
+
+    let client = reqwest::Client::new();
+    let headers = reqwest::header::HeaderMap::new();
+
+    let result = fetch_components(&client, &server.url(), &headers).await;
+
+    assert!(result.is_ok());
+    let components = result.unwrap();
+    assert_eq!(components.len(), 2);
+    assert_eq!(components[0].id, 218);
+    assert_eq!(components[0].name, "Object Storage Service");
+    assert_eq!(components[0].attributes.len(), 2);
+    assert_eq!(components[1].id, 254);
+
+    mock.assert_async().await;
+}
+
+/// T030: Test build_component_id_cache - verify cache structure with nested HashMap
+#[test]
+fn test_build_component_id_cache() {
+    let components = vec![
+        StatusDashboardComponent {
+            id: 218,
+            name: "Object Storage Service".to_string(),
+            attributes: vec![
+                ComponentAttribute {
+                    name: "category".to_string(),
+                    value: "Storage".to_string(),
+                },
+                ComponentAttribute {
+                    name: "region".to_string(),
+                    value: "EU-DE".to_string(),
+                },
+            ],
+        },
+        StatusDashboardComponent {
+            id: 254,
+            name: "Compute Service".to_string(),
+            attributes: vec![
+                ComponentAttribute {
+                    name: "category".to_string(),
+                    value: "Compute".to_string(),
+                },
+                ComponentAttribute {
+                    name: "region".to_string(),
+                    value: "EU-NL".to_string(),
+                },
+            ],
+        },
+    ];
+
+    let cache = build_component_id_cache(components);
+
+    // Verify cache structure
+    assert_eq!(cache.len(), 2);
+
+    // Build expected key with sorted attributes
+    let mut key1_attrs = vec![
+        ComponentAttribute {
+            name: "category".to_string(),
+            value: "Storage".to_string(),
+        },
+        ComponentAttribute {
+            name: "region".to_string(),
+            value: "EU-DE".to_string(),
+        },
+    ];
+    key1_attrs.sort();
+    let key1 = ("Object Storage Service".to_string(), key1_attrs);
+
+    assert_eq!(cache.get(&key1), Some(&218));
+}
+
+/// T031: Test find_component_id_subset_matching - verify FR-012 subset attribute matching
+#[test]
+fn test_find_component_id_subset_matching() {
+    // Build cache with components that have multiple attributes
+    let components = vec![StatusDashboardComponent {
+        id: 218,
+        name: "Object Storage Service".to_string(),
+        attributes: vec![
+            ComponentAttribute {
+                name: "category".to_string(),
+                value: "Storage".to_string(),
+            },
+            ComponentAttribute {
+                name: "region".to_string(),
+                value: "EU-DE".to_string(),
+            },
+            ComponentAttribute {
+                name: "type".to_string(),
+                value: "block".to_string(),
+            },
+        ],
+    }];
+
+    let cache = build_component_id_cache(components);
+
+    // Test 1: Exact match
+    let target_exact = Component {
+        name: "Object Storage Service".to_string(),
+        attributes: vec![
+            ComponentAttribute {
+                name: "category".to_string(),
+                value: "Storage".to_string(),
+            },
+            ComponentAttribute {
+                name: "region".to_string(),
+                value: "EU-DE".to_string(),
+            },
+            ComponentAttribute {
+                name: "type".to_string(),
+                value: "block".to_string(),
+            },
+        ],
+    };
+    assert_eq!(find_component_id(&cache, &target_exact), Some(218));
+
+    // Test 2: Subset match (config has fewer attributes than cache) - FR-012
+    let target_subset = Component {
+        name: "Object Storage Service".to_string(),
+        attributes: vec![ComponentAttribute {
+            name: "region".to_string(),
+            value: "EU-DE".to_string(),
+        }],
+    };
+    assert_eq!(find_component_id(&cache, &target_subset), Some(218));
+
+    // Test 3: No match (different attribute value)
+    let target_no_match = Component {
+        name: "Object Storage Service".to_string(),
+        attributes: vec![ComponentAttribute {
+            name: "region".to_string(),
+            value: "EU-NL".to_string(),
+        }],
+    };
+    assert_eq!(find_component_id(&cache, &target_no_match), None);
+
+    // Test 4: No match (component name doesn't exist)
+    let target_no_name = Component {
+        name: "NonExistent Service".to_string(),
+        attributes: vec![],
+    };
+    assert_eq!(find_component_id(&cache, &target_no_name), None);
+}
+
+/// T032: Test build_incident_data_structure - verify static title/description per FR-002
+#[test]
+fn test_build_incident_data_structure() {
+    let component_id = 218;
+    let impact = 2;
+    let timestamp = 1705929045; // 2024-01-22 10:30:45 UTC
+
+    let incident_data = build_incident_data(component_id, impact, timestamp);
+
+    // Verify static title and description (FR-002)
+    assert_eq!(
+        incident_data.title,
+        "System incident from monitoring system"
+    );
+    assert_eq!(
+        incident_data.description,
+        "System-wide incident affecting one or multiple components. Created automatically."
+    );
+
+    // Verify other fields
+    assert_eq!(incident_data.impact, 2);
+    assert_eq!(incident_data.components, vec![218]);
+    assert_eq!(incident_data.system, true);
+    assert_eq!(incident_data.incident_type, "incident");
+}
+
+/// T033: Test timestamp_rfc3339_minus_one_second - verify FR-011 timestamp handling
+#[test]
+fn test_timestamp_rfc3339_minus_one_second() {
+    let timestamp = 1705929045; // 2024-01-22 10:30:45 UTC
+    let incident_data = build_incident_data(218, 2, timestamp);
+
+    // Parse the start_date back to verify it's RFC3339 and -1 second
+    let parsed = DateTime::parse_from_rfc3339(&incident_data.start_date);
+    assert!(parsed.is_ok());
+
+    let expected_timestamp = timestamp - 1; // FR-011: subtract 1 second
+    let expected_dt = DateTime::from_timestamp(expected_timestamp, 0).unwrap();
+
+    assert_eq!(parsed.unwrap().timestamp(), expected_dt.timestamp());
+
+    // Verify the format is RFC3339 (contains 'T' and 'Z' or offset)
+    assert!(incident_data.start_date.contains('T'));
+    assert!(incident_data.start_date.ends_with('Z') || incident_data.start_date.contains('+'));
+}
+
+/// T034: Test create_incident_success - verify POST with mockito
+#[tokio::test]
+async fn test_create_incident_success() {
+    let mut server = mockito::Server::new_async().await;
+
+    // Mock POST endpoint
+    let mock = server
+        .mock("POST", "/v2/events")
+        .with_status(200)
+        .with_header("content-type", "application/json")
+        .with_body(
+            r#"{
+                "result": [
+                    {
+                        "component_id": 218,
+                        "incident_id": 456
+                    }
+                ]
+            }"#,
+        )
+        .match_header("content-type", "application/json")
+        .create_async()
+        .await;
+
+    let client = reqwest::Client::new();
+    let headers = reqwest::header::HeaderMap::new();
+
+    let incident_data = IncidentData {
+        title: "System incident from monitoring system".to_string(),
+        description: "Test incident".to_string(),
+        impact: 2,
+        components: vec![218],
+        start_date: "2024-01-22T10:30:44Z".to_string(),
+        system: true,
+        incident_type: "incident".to_string(),
+    };
+
+    let result = create_incident(&client, &server.url(), &headers, &incident_data).await;
+
+    assert!(result.is_ok());
+    mock.assert_async().await;
+}
+
+/// T035: Test cache_refresh_on_miss - verify FR-005 single refresh attempt
+/// Note: This is more of a behavior test that would require running the full reporter
+/// For now, we test the logic components separately
+#[test]
+fn test_cache_refresh_logic() {
+    // Test scenario: component not found initially, would trigger refresh
+    let initial_cache = build_component_id_cache(vec![StatusDashboardComponent {
+        id: 218,
+        name: "Service A".to_string(),
+        attributes: vec![],
+    }]);
+
+    let target = Component {
+        name: "Service B".to_string(),
+        attributes: vec![],
+    };
+
+    // First lookup fails
+    let result = find_component_id(&initial_cache, &target);
+    assert_eq!(result, None);
+
+    // After refresh (simulated by building new cache with additional component)
+    let refreshed_cache = build_component_id_cache(vec![
+        StatusDashboardComponent {
+            id: 218,
+            name: "Service A".to_string(),
+            attributes: vec![],
+        },
+        StatusDashboardComponent {
+            id: 254,
+            name: "Service B".to_string(),
+            attributes: vec![],
+        },
+    ]);
+
+    // Second lookup succeeds
+    let result = find_component_id(&refreshed_cache, &target);
+    assert_eq!(result, Some(254));
+}
+
+/// T036: Test startup_retry_logic - verify FR-006 3 retry attempts with delays
+/// Note: Full integration would test actual delays, here we verify the logic structure
+#[tokio::test]
+async fn test_startup_fetch_with_retries() {
+    let mut server = mockito::Server::new_async().await;
+
+    // First two attempts fail, third succeeds
+    let mock_fail_1 = server
+        .mock("GET", "/v2/components")
+        .with_status(503)
+        .expect(1)
+        .create_async()
+        .await;
+
+    let mock_fail_2 = server
+        .mock("GET", "/v2/components")
+        .with_status(503)
+        .expect(1)
+        .create_async()
+        .await;
+
+    let mock_success = server
+        .mock("GET", "/v2/components")
+        .with_status(200)
+        .with_body(r#"[{"id": 218, "name": "Test Service", "attributes": []}]"#)
+        .expect(1)
+        .create_async()
+        .await;
+
+    let client = reqwest::Client::new();
+    let headers = reqwest::header::HeaderMap::new();
+
+    // Simulate retry logic
+    let mut attempt = 0;
+    let max_attempts = 3;
+    let mut result = None;
+
+    while attempt < max_attempts {
+        attempt += 1;
+        match fetch_components(&client, &server.url(), &headers).await {
+            Ok(components) => {
+                result = Some(components);
+                break;
+            }
+            Err(_) if attempt < max_attempts => {
+                // Would sleep here in real code
+                continue;
+            }
+            Err(_) => {
+                break;
+            }
+        }
+    }
+
+    assert!(result.is_some());
+    assert_eq!(attempt, 3); // Succeeded on third attempt
+
+    mock_fail_1.assert_async().await;
+    mock_fail_2.assert_async().await;
+    mock_success.assert_async().await;
+}
+
+/// T037: Test error_logging_with_diagnostic_fields - verify FR-017 structured logging
+/// Note: This test verifies data structures support structured logging
+#[test]
+fn test_diagnostic_data_availability() {
+    // Verify all required fields for structured logging are accessible
+    let component = Component {
+        name: "Test Service".to_string(),
+        attributes: vec![ComponentAttribute {
+            name: "region".to_string(),
+            value: "EU-DE".to_string(),
+        }],
+    };
+
+    let incident_data = build_incident_data(218, 2, 1705929045);
+
+    // All these fields should be accessible for logging (FR-017)
+    assert!(!component.name.is_empty());
+    assert!(!component.attributes.is_empty());
+    assert_eq!(incident_data.components[0], 218);
+    assert_eq!(incident_data.impact, 2);
+    assert!(!incident_data.start_date.is_empty());
+
+    // Verify ComponentAttribute derives support structured logging
+    let attr = &component.attributes[0];
+    assert_eq!(attr.name, "region");
+    assert_eq!(attr.value, "EU-DE");
+}
+
+/// Additional test: Verify empty attributes work correctly
+#[test]
+fn test_empty_attributes_handling() {
+    let components = vec![StatusDashboardComponent {
+        id: 100,
+        name: "Service Without Attributes".to_string(),
+        attributes: vec![],
+    }];
+
+    let cache = build_component_id_cache(components);
+
+    let target = Component {
+        name: "Service Without Attributes".to_string(),
+        attributes: vec![],
+    };
+
+    assert_eq!(find_component_id(&cache, &target), Some(100));
+}
+
+/// Additional test: Verify multiple components with same name but different attributes
+#[test]
+fn test_multiple_components_same_name() {
+    let components = vec![
+        StatusDashboardComponent {
+            id: 100,
+            name: "Storage Service".to_string(),
+            attributes: vec![ComponentAttribute {
+                name: "region".to_string(),
+                value: "EU-DE".to_string(),
+            }],
+        },
+        StatusDashboardComponent {
+            id: 200,
+            name: "Storage Service".to_string(),
+            attributes: vec![ComponentAttribute {
+                name: "region".to_string(),
+                value: "EU-NL".to_string(),
+            }],
+        },
+    ];
+
+    let cache = build_component_id_cache(components);
+
+    let target_de = Component {
+        name: "Storage Service".to_string(),
+        attributes: vec![ComponentAttribute {
+            name: "region".to_string(),
+            value: "EU-DE".to_string(),
+        }],
+    };
+
+    let target_nl = Component {
+        name: "Storage Service".to_string(),
+        attributes: vec![ComponentAttribute {
+            name: "region".to_string(),
+            value: "EU-NL".to_string(),
+        }],
+    };
+
+    assert_eq!(find_component_id(&cache, &target_de), Some(100));
+    assert_eq!(find_component_id(&cache, &target_nl), Some(200));
+}
+
+/// Test build_auth_headers - verify JWT token generation
+#[test]
+fn test_build_auth_headers() {
+    // Test with secret
+    let headers = build_auth_headers(Some("test-secret"));
+    assert!(headers.contains_key(reqwest::header::AUTHORIZATION));
+
+    let auth_value = headers.get(reqwest::header::AUTHORIZATION).unwrap();
+    let auth_str = auth_value.to_str().unwrap();
+    assert!(auth_str.starts_with("Bearer "));
+
+    // Test without secret (optional auth)
+    let headers_empty = build_auth_headers(None);
+    assert!(!headers_empty.contains_key(reqwest::header::AUTHORIZATION));
+}
+
+/// Test create_incident failure - verify error handling when API returns error
+#[tokio::test]
+async fn test_create_incident_failure() {
+    let mut server = mockito::Server::new_async().await;
+
+    // Mock POST /v2/events to return 500 error (note: actual endpoint is /v2/events)
+    let mock = server
+        .mock("POST", "/v2/events")
+        .with_status(500)
+        .with_header("content-type", "application/json")
+        .with_body(r#"{"error": "Internal Server Error"}"#)
+        .expect(1)
+        .create_async()
+        .await;
+
+    let client = reqwest::Client::new();
+    let headers = reqwest::header::HeaderMap::new();
+
+    let incident_data = IncidentData {
+        title: "System incident from monitoring system".to_string(),
+        description: "Test incident".to_string(),
+        impact: 2,
+        components: vec![218],
+        start_date: "2024-01-22T10:30:44Z".to_string(),
+        system: true,
+        incident_type: "incident".to_string(),
+    };
+
+    let result = create_incident(&client, &server.url(), &headers, &incident_data).await;
+
+    assert!(result.is_err(), "create_incident should fail on 500 error");
+    let err_msg = result.unwrap_err().to_string();
+    assert!(
+        err_msg.contains("Failed to create incident"),
+        "Error message should mention failure: {}",
+        err_msg
+    );
+
+    mock.assert_async().await;
+}
+
+/// Test fetch_components failure - verify error handling when API returns error
+#[tokio::test]
+async fn test_fetch_components_failure() {
+    let mut server = mockito::Server::new_async().await;
+
+    // Mock GET /v2/components to return 503 error
+    let mock = server
+        .mock("GET", "/v2/components")
+        .with_status(503)
+        .with_body("Service Unavailable")
+        .create_async()
+        .await;
+
+    let client = reqwest::Client::new();
+    let headers = reqwest::header::HeaderMap::new();
+
+    let result = fetch_components(&client, &server.url(), &headers).await;
+
+    assert!(result.is_err(), "fetch_components should fail on 503 error");
+    let err_msg = result.unwrap_err().to_string();
+    assert!(
+        err_msg.contains("Failed to fetch components"),
+        "Error message should mention failure"
+    );
+
+    mock.assert_async().await;
+}